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 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1603 val
= iterative_hash_template_arg (field
, val
);
1604 val
= iterative_hash_template_arg (value
, val
);
1610 if (!DECL_ARTIFICIAL (arg
))
1612 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1613 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1615 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1618 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1621 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1622 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1624 case TEMPLATE_PARM_INDEX
:
1625 val
= iterative_hash_template_arg
1626 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1627 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1628 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1631 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1632 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1633 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1636 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1638 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1642 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1643 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1644 val
= iterative_hash_object (code
, val
);
1645 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1648 /* A lambda can't appear in a template arg, but don't crash on
1650 gcc_assert (seen_error ());
1654 case IMPLICIT_CONV_EXPR
:
1655 case STATIC_CAST_EXPR
:
1656 case REINTERPRET_CAST_EXPR
:
1657 case CONST_CAST_EXPR
:
1658 case DYNAMIC_CAST_EXPR
:
1660 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1661 /* Now hash operands as usual. */
1671 if (TYPE_CANONICAL (arg
))
1672 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1674 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1675 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1676 /* Otherwise just compare the types during lookup. */
1679 case tcc_declaration
:
1681 return iterative_hash_expr (arg
, val
);
1684 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1686 unsigned n
= cp_tree_operand_length (arg
);
1687 for (i
= 0; i
< n
; ++i
)
1688 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1696 /* Unregister the specialization SPEC as a specialization of TMPL.
1697 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1698 if the SPEC was listed as a specialization of TMPL.
1700 Note that SPEC has been ggc_freed, so we can't look inside it. */
1703 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1708 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1709 elt
.args
= TI_ARGS (tinfo
);
1710 elt
.spec
= NULL_TREE
;
1712 entry
= (spec_entry
*) htab_find (decl_specializations
, &elt
);
1715 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1716 gcc_assert (new_spec
!= NULL_TREE
);
1717 entry
->spec
= new_spec
;
1724 /* Like register_specialization, but for local declarations. We are
1725 registering SPEC, an instantiation of TMPL. */
1728 register_local_specialization (tree spec
, tree tmpl
)
1730 local_specializations
->put (tmpl
, spec
);
1733 /* TYPE is a class type. Returns true if TYPE is an explicitly
1734 specialized class. */
1737 explicit_class_specialization_p (tree type
)
1739 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1741 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1744 /* Print the list of functions at FNS, going through all the overloads
1745 for each element of the list. Alternatively, FNS can not be a
1746 TREE_LIST, in which case it will be printed together with all the
1749 MORE and *STR should respectively be FALSE and NULL when the function
1750 is called from the outside. They are used internally on recursive
1751 calls. print_candidates manages the two parameters and leaves NULL
1752 in *STR when it ends. */
1755 print_candidates_1 (tree fns
, bool more
, const char **str
)
1758 char *spaces
= NULL
;
1760 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
1761 if (TREE_CODE (fn
) == TREE_LIST
)
1763 for (fn2
= fn
; fn2
!= NULL_TREE
; fn2
= TREE_CHAIN (fn2
))
1764 print_candidates_1 (TREE_VALUE (fn2
),
1765 TREE_CHAIN (fn2
) || more
, str
);
1769 tree cand
= OVL_CURRENT (fn
);
1772 /* Pick the prefix string. */
1773 if (!more
&& !OVL_NEXT (fns
))
1775 inform (DECL_SOURCE_LOCATION (cand
),
1776 "candidate is: %#D", cand
);
1780 *str
= _("candidates are:");
1781 spaces
= get_spaces (*str
);
1783 inform (DECL_SOURCE_LOCATION (cand
), "%s %#D", *str
, cand
);
1784 *str
= spaces
? spaces
: *str
;
1794 /* Print the list of candidate FNS in an error message. FNS can also
1795 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1798 print_candidates (tree fns
)
1800 const char *str
= NULL
;
1801 print_candidates_1 (fns
, false, &str
);
1802 gcc_assert (str
== NULL
);
1805 /* Returns the template (one of the functions given by TEMPLATE_ID)
1806 which can be specialized to match the indicated DECL with the
1807 explicit template args given in TEMPLATE_ID. The DECL may be
1808 NULL_TREE if none is available. In that case, the functions in
1809 TEMPLATE_ID are non-members.
1811 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1812 specialization of a member template.
1814 The TEMPLATE_COUNT is the number of references to qualifying
1815 template classes that appeared in the name of the function. See
1816 check_explicit_specialization for a more accurate description.
1818 TSK indicates what kind of template declaration (if any) is being
1819 declared. TSK_TEMPLATE indicates that the declaration given by
1820 DECL, though a FUNCTION_DECL, has template parameters, and is
1821 therefore a template function.
1823 The template args (those explicitly specified and those deduced)
1824 are output in a newly created vector *TARGS_OUT.
1826 If it is impossible to determine the result, an error message is
1827 issued. The error_mark_node is returned to indicate failure. */
1830 determine_specialization (tree template_id
,
1833 int need_member_template
,
1839 tree explicit_targs
;
1840 tree candidates
= NULL_TREE
;
1841 /* A TREE_LIST of templates of which DECL may be a specialization.
1842 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1843 corresponding TREE_PURPOSE is the set of template arguments that,
1844 when used to instantiate the template, would produce a function
1845 with the signature of DECL. */
1846 tree templates
= NULL_TREE
;
1848 cp_binding_level
*b
;
1850 *targs_out
= NULL_TREE
;
1852 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1853 return error_mark_node
;
1855 /* We shouldn't be specializing a member template of an
1856 unspecialized class template; we already gave an error in
1857 check_specialization_scope, now avoid crashing. */
1858 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
1859 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
1861 gcc_assert (errorcount
);
1862 return error_mark_node
;
1865 fns
= TREE_OPERAND (template_id
, 0);
1866 explicit_targs
= TREE_OPERAND (template_id
, 1);
1868 if (fns
== error_mark_node
)
1869 return error_mark_node
;
1871 /* Check for baselinks. */
1872 if (BASELINK_P (fns
))
1873 fns
= BASELINK_FUNCTIONS (fns
);
1875 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
1877 error ("%qD is not a function template", fns
);
1878 return error_mark_node
;
1880 else if (VAR_P (decl
) && !variable_template_p (fns
))
1882 error ("%qD is not a variable template", fns
);
1883 return error_mark_node
;
1886 /* Count the number of template headers specified for this
1889 for (b
= current_binding_level
;
1890 b
->kind
== sk_template_parms
;
1894 if (variable_template_p (fns
))
1895 templates
= tree_cons (explicit_targs
, fns
, templates
);
1896 else for (; fns
; fns
= OVL_NEXT (fns
))
1898 tree fn
= OVL_CURRENT (fns
);
1900 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1902 tree decl_arg_types
;
1906 /* In case of explicit specialization, we need to check if
1907 the number of template headers appearing in the specialization
1908 is correct. This is usually done in check_explicit_specialization,
1909 but the check done there cannot be exhaustive when specializing
1910 member functions. Consider the following code:
1912 template <> void A<int>::f(int);
1913 template <> template <> void A<int>::f(int);
1915 Assuming that A<int> is not itself an explicit specialization
1916 already, the first line specializes "f" which is a non-template
1917 member function, whilst the second line specializes "f" which
1918 is a template member function. So both lines are syntactically
1919 correct, and check_explicit_specialization does not reject
1922 Here, we can do better, as we are matching the specialization
1923 against the declarations. We count the number of template
1924 headers, and we check if they match TEMPLATE_COUNT + 1
1925 (TEMPLATE_COUNT is the number of qualifying template classes,
1926 plus there must be another header for the member template
1929 Notice that if header_count is zero, this is not a
1930 specialization but rather a template instantiation, so there
1931 is no check we can perform here. */
1932 if (header_count
&& header_count
!= template_count
+ 1)
1935 /* Check that the number of template arguments at the
1936 innermost level for DECL is the same as for FN. */
1937 if (current_binding_level
->kind
== sk_template_parms
1938 && !current_binding_level
->explicit_spec_p
1939 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1940 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1941 (current_template_parms
))))
1944 /* DECL might be a specialization of FN. */
1945 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1946 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1948 /* For a non-static member function, we need to make sure
1949 that the const qualification is the same. Since
1950 get_bindings does not try to merge the "this" parameter,
1951 we must do the comparison explicitly. */
1952 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1953 && !same_type_p (TREE_VALUE (fn_arg_types
),
1954 TREE_VALUE (decl_arg_types
)))
1957 /* Skip the "this" parameter and, for constructors of
1958 classes with virtual bases, the VTT parameter. A
1959 full specialization of a constructor will have a VTT
1960 parameter, but a template never will. */
1962 = skip_artificial_parms_for (decl
, decl_arg_types
);
1964 = skip_artificial_parms_for (fn
, fn_arg_types
);
1966 /* Function templates cannot be specializations; there are
1967 no partial specializations of functions. Therefore, if
1968 the type of DECL does not match FN, there is no
1970 if (tsk
== tsk_template
)
1972 if (compparms (fn_arg_types
, decl_arg_types
))
1973 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1977 /* See whether this function might be a specialization of this
1978 template. Suppress access control because we might be trying
1979 to make this specialization a friend, and we have already done
1980 access control for the declaration of the specialization. */
1981 push_deferring_access_checks (dk_no_check
);
1982 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
1983 pop_deferring_access_checks ();
1986 /* We cannot deduce template arguments that when used to
1987 specialize TMPL will produce DECL. */
1990 /* Make sure that the deduced arguments actually work. */
1991 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
1992 if (insttype
== error_mark_node
)
1995 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
1996 if (!compparms (fn_arg_types
, decl_arg_types
))
1999 /* Save this template, and the arguments deduced. */
2000 templates
= tree_cons (targs
, fn
, templates
);
2002 else if (need_member_template
)
2003 /* FN is an ordinary member function, and we need a
2004 specialization of a member template. */
2006 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2007 /* We can get IDENTIFIER_NODEs here in certain erroneous
2010 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2011 /* This is just an ordinary non-member function. Nothing can
2012 be a specialization of that. */
2014 else if (DECL_ARTIFICIAL (fn
))
2015 /* Cannot specialize functions that are created implicitly. */
2019 tree decl_arg_types
;
2021 /* This is an ordinary member function. However, since
2022 we're here, we can assume its enclosing class is a
2023 template class. For example,
2025 template <typename T> struct S { void f(); };
2026 template <> void S<int>::f() {}
2028 Here, S<int>::f is a non-template, but S<int> is a
2029 template class. If FN has the same type as DECL, we
2030 might be in business. */
2032 if (!DECL_TEMPLATE_INFO (fn
))
2033 /* Its enclosing class is an explicit specialization
2034 of a template class. This is not a candidate. */
2037 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2038 TREE_TYPE (TREE_TYPE (fn
))))
2039 /* The return types differ. */
2042 /* Adjust the type of DECL in case FN is a static member. */
2043 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2044 if (DECL_STATIC_FUNCTION_P (fn
)
2045 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2046 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2048 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2051 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2055 if (templates
&& TREE_CHAIN (templates
))
2061 It is possible for a specialization with a given function
2062 signature to be instantiated from more than one function
2063 template. In such cases, explicit specification of the
2064 template arguments must be used to uniquely identify the
2065 function template specialization being specialized.
2067 Note that here, there's no suggestion that we're supposed to
2068 determine which of the candidate templates is most
2069 specialized. However, we, also have:
2073 Partial ordering of overloaded function template
2074 declarations is used in the following contexts to select
2075 the function template to which a function template
2076 specialization refers:
2078 -- when an explicit specialization refers to a function
2081 So, we do use the partial ordering rules, at least for now.
2082 This extension can only serve to make invalid programs valid,
2083 so it's safe. And, there is strong anecdotal evidence that
2084 the committee intended the partial ordering rules to apply;
2085 the EDG front end has that behavior, and John Spicer claims
2086 that the committee simply forgot to delete the wording in
2087 [temp.expl.spec]. */
2088 tree tmpl
= most_specialized_instantiation (templates
);
2089 if (tmpl
!= error_mark_node
)
2092 TREE_CHAIN (templates
) = NULL_TREE
;
2096 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2098 error ("template-id %qD for %q+D does not match any template "
2099 "declaration", template_id
, decl
);
2100 if (header_count
&& header_count
!= template_count
+ 1)
2101 inform (input_location
, "saw %d %<template<>%>, need %d for "
2102 "specializing a member function template",
2103 header_count
, template_count
+ 1);
2104 return error_mark_node
;
2106 else if ((templates
&& TREE_CHAIN (templates
))
2107 || (candidates
&& TREE_CHAIN (candidates
))
2108 || (templates
&& candidates
))
2110 error ("ambiguous template specialization %qD for %q+D",
2112 candidates
= chainon (candidates
, templates
);
2113 print_candidates (candidates
);
2114 return error_mark_node
;
2117 /* We have one, and exactly one, match. */
2120 tree fn
= TREE_VALUE (candidates
);
2121 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2122 /* DECL is a re-declaration or partial instantiation of a template
2124 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2126 /* It was a specialization of an ordinary member function in a
2128 return DECL_TI_TEMPLATE (fn
);
2131 /* It was a specialization of a template. */
2132 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2133 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2135 *targs_out
= copy_node (targs
);
2136 SET_TMPL_ARGS_LEVEL (*targs_out
,
2137 TMPL_ARGS_DEPTH (*targs_out
),
2138 TREE_PURPOSE (templates
));
2141 *targs_out
= TREE_PURPOSE (templates
);
2142 return TREE_VALUE (templates
);
2145 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2146 but with the default argument values filled in from those in the
2150 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2153 tree new_spec_types
;
2158 if (spec_types
== void_list_node
)
2159 return void_list_node
;
2161 /* Substitute into the rest of the list. */
2163 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2164 TREE_CHAIN (tmpl_types
));
2166 /* Add the default argument for this parameter. */
2167 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2168 TREE_VALUE (spec_types
),
2172 /* DECL is an explicit specialization. Replicate default arguments
2173 from the template it specializes. (That way, code like:
2175 template <class T> void f(T = 3);
2176 template <> void f(double);
2179 works, as required.) An alternative approach would be to look up
2180 the correct default arguments at the call-site, but this approach
2181 is consistent with how implicit instantiations are handled. */
2184 copy_default_args_to_explicit_spec (tree decl
)
2189 tree new_spec_types
;
2193 tree object_type
= NULL_TREE
;
2194 tree in_charge
= NULL_TREE
;
2195 tree vtt
= NULL_TREE
;
2197 /* See if there's anything we need to do. */
2198 tmpl
= DECL_TI_TEMPLATE (decl
);
2199 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2200 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2201 if (TREE_PURPOSE (t
))
2206 old_type
= TREE_TYPE (decl
);
2207 spec_types
= TYPE_ARG_TYPES (old_type
);
2209 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2211 /* Remove the this pointer, but remember the object's type for
2213 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2214 spec_types
= TREE_CHAIN (spec_types
);
2215 tmpl_types
= TREE_CHAIN (tmpl_types
);
2217 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2219 /* DECL may contain more parameters than TMPL due to the extra
2220 in-charge parameter in constructors and destructors. */
2221 in_charge
= spec_types
;
2222 spec_types
= TREE_CHAIN (spec_types
);
2224 if (DECL_HAS_VTT_PARM_P (decl
))
2227 spec_types
= TREE_CHAIN (spec_types
);
2231 /* Compute the merged default arguments. */
2233 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2235 /* Compute the new FUNCTION_TYPE. */
2239 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2244 /* Put the in-charge parameter back. */
2245 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2246 TREE_VALUE (in_charge
),
2249 new_type
= build_method_type_directly (object_type
,
2250 TREE_TYPE (old_type
),
2254 new_type
= build_function_type (TREE_TYPE (old_type
),
2256 new_type
= cp_build_type_attribute_variant (new_type
,
2257 TYPE_ATTRIBUTES (old_type
));
2258 new_type
= build_exception_variant (new_type
,
2259 TYPE_RAISES_EXCEPTIONS (old_type
));
2261 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2262 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2264 TREE_TYPE (decl
) = new_type
;
2267 /* Return the number of template headers we expect to see for a definition
2268 or specialization of CTYPE or one of its non-template members. */
2271 num_template_headers_for_class (tree ctype
)
2273 int num_templates
= 0;
2275 while (ctype
&& CLASS_TYPE_P (ctype
))
2277 /* You're supposed to have one `template <...>' for every
2278 template class, but you don't need one for a full
2279 specialization. For example:
2281 template <class T> struct S{};
2282 template <> struct S<int> { void f(); };
2283 void S<int>::f () {}
2285 is correct; there shouldn't be a `template <>' for the
2286 definition of `S<int>::f'. */
2287 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2288 /* If CTYPE does not have template information of any
2289 kind, then it is not a template, nor is it nested
2290 within a template. */
2292 if (explicit_class_specialization_p (ctype
))
2294 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2297 ctype
= TYPE_CONTEXT (ctype
);
2300 return num_templates
;
2303 /* Do a simple sanity check on the template headers that precede the
2304 variable declaration DECL. */
2307 check_template_variable (tree decl
)
2309 tree ctx
= CP_DECL_CONTEXT (decl
);
2310 int wanted
= num_template_headers_for_class (ctx
);
2311 if (!TYPE_P (ctx
) || !CLASSTYPE_TEMPLATE_INFO (ctx
))
2313 if (cxx_dialect
< cxx1y
)
2314 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2315 "variable templates only available with "
2316 "-std=c++1y or -std=gnu++1y");
2318 // Namespace-scope variable templates should have a template header.
2321 if (template_header_count
> wanted
)
2323 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2324 "too many template headers for %D (should be %d)",
2326 if (warned
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2327 inform (DECL_SOURCE_LOCATION (decl
),
2328 "members of an explicitly specialized class are defined "
2329 "without a template header");
2333 /* Check to see if the function just declared, as indicated in
2334 DECLARATOR, and in DECL, is a specialization of a function
2335 template. We may also discover that the declaration is an explicit
2336 instantiation at this point.
2338 Returns DECL, or an equivalent declaration that should be used
2339 instead if all goes well. Issues an error message if something is
2340 amiss. Returns error_mark_node if the error is not easily
2343 FLAGS is a bitmask consisting of the following flags:
2345 2: The function has a definition.
2346 4: The function is a friend.
2348 The TEMPLATE_COUNT is the number of references to qualifying
2349 template classes that appeared in the name of the function. For
2352 template <class T> struct S { void f(); };
2355 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2356 classes are not counted in the TEMPLATE_COUNT, so that in
2358 template <class T> struct S {};
2359 template <> struct S<int> { void f(); }
2360 template <> void S<int>::f();
2362 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2363 invalid; there should be no template <>.)
2365 If the function is a specialization, it is marked as such via
2366 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2367 is set up correctly, and it is added to the list of specializations
2368 for that template. */
2371 check_explicit_specialization (tree declarator
,
2376 int have_def
= flags
& 2;
2377 int is_friend
= flags
& 4;
2378 int specialization
= 0;
2379 int explicit_instantiation
= 0;
2380 int member_specialization
= 0;
2381 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2382 tree dname
= DECL_NAME (decl
);
2387 if (!processing_specialization
)
2390 tsk
= tsk_excessive_parms
;
2393 tsk
= current_tmpl_spec_kind (template_count
);
2398 if (processing_specialization
)
2401 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2403 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2406 /* This could be something like:
2408 template <class T> void f(T);
2409 class S { friend void f<>(int); } */
2413 /* This case handles bogus declarations like template <>
2414 template <class T> void f<int>(); */
2416 error ("template-id %qD in declaration of primary template",
2423 case tsk_invalid_member_spec
:
2424 /* The error has already been reported in
2425 check_specialization_scope. */
2426 return error_mark_node
;
2428 case tsk_invalid_expl_inst
:
2429 error ("template parameter list used in explicit instantiation");
2435 error ("definition provided for explicit instantiation");
2437 explicit_instantiation
= 1;
2440 case tsk_excessive_parms
:
2441 case tsk_insufficient_parms
:
2442 if (tsk
== tsk_excessive_parms
)
2443 error ("too many template parameter lists in declaration of %qD",
2445 else if (template_header_count
)
2446 error("too few template parameter lists in declaration of %qD", decl
);
2448 error("explicit specialization of %qD must be introduced by "
2449 "%<template <>%>", decl
);
2453 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2455 // In cases like template<> constexpr bool v = true;
2456 error ("%qD is not a template variable", dname
);
2460 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2462 member_specialization
= 1;
2468 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2470 /* This case handles bogus declarations like template <>
2471 template <class T> void f<int>(); */
2473 if (uses_template_parms (declarator
))
2474 error ("function template partial specialization %qD "
2475 "is not allowed", declarator
);
2477 error ("template-id %qD in declaration of primary template",
2482 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2483 /* This is a specialization of a member template, without
2484 specialization the containing class. Something like:
2486 template <class T> struct S {
2487 template <class U> void f (U);
2489 template <> template <class U> void S<int>::f(U) {}
2491 That's a specialization -- but of the entire template. */
2499 if ((specialization
|| member_specialization
)
2500 /* This doesn't apply to variable templates. */
2501 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2502 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2504 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2505 for (; t
; t
= TREE_CHAIN (t
))
2506 if (TREE_PURPOSE (t
))
2508 permerror (input_location
,
2509 "default argument specified in explicit specialization");
2514 if (specialization
|| member_specialization
|| explicit_instantiation
)
2516 tree tmpl
= NULL_TREE
;
2517 tree targs
= NULL_TREE
;
2519 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2520 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2524 gcc_assert (identifier_p (declarator
));
2529 /* If there is no class context, the explicit instantiation
2530 must be at namespace scope. */
2531 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2533 /* Find the namespace binding, using the declaration
2535 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2537 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2539 error ("%qD is not a template function", dname
);
2540 fns
= error_mark_node
;
2544 tree fn
= OVL_CURRENT (fns
);
2545 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2546 CP_DECL_CONTEXT (fn
)))
2547 error ("%qD is not declared in %qD",
2548 decl
, current_namespace
);
2552 declarator
= lookup_template_function (fns
, NULL_TREE
);
2555 if (declarator
== error_mark_node
)
2556 return error_mark_node
;
2558 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2560 if (!explicit_instantiation
)
2561 /* A specialization in class scope. This is invalid,
2562 but the error will already have been flagged by
2563 check_specialization_scope. */
2564 return error_mark_node
;
2567 /* It's not valid to write an explicit instantiation in
2570 class C { template void f(); }
2572 This case is caught by the parser. However, on
2575 template class C { void f(); };
2577 (which is invalid) we can get here. The error will be
2584 else if (ctype
!= NULL_TREE
2585 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2587 // Ignore variable templates.
2591 /* Find the list of functions in ctype that have the same
2592 name as the declared function. */
2593 tree name
= TREE_OPERAND (declarator
, 0);
2594 tree fns
= NULL_TREE
;
2597 if (constructor_name_p (name
, ctype
))
2599 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2601 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2602 : !CLASSTYPE_DESTRUCTORS (ctype
))
2604 /* From [temp.expl.spec]:
2606 If such an explicit specialization for the member
2607 of a class template names an implicitly-declared
2608 special member function (clause _special_), the
2609 program is ill-formed.
2611 Similar language is found in [temp.explicit]. */
2612 error ("specialization of implicitly-declared special member function");
2613 return error_mark_node
;
2616 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2619 if (!DECL_CONV_FN_P (decl
))
2621 idx
= lookup_fnfields_1 (ctype
, name
);
2623 fns
= (*CLASSTYPE_METHOD_VEC (ctype
))[idx
];
2627 vec
<tree
, va_gc
> *methods
;
2630 /* For a type-conversion operator, we cannot do a
2631 name-based lookup. We might be looking for `operator
2632 int' which will be a specialization of `operator T'.
2633 So, we find *all* the conversion operators, and then
2634 select from them. */
2637 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2639 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2640 methods
->iterate (idx
, &ovl
);
2643 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2644 /* There are no more conversion functions. */
2647 /* Glue all these conversion functions together
2648 with those we already have. */
2649 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2650 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2654 if (fns
== NULL_TREE
)
2656 error ("no member function %qD declared in %qT", name
, ctype
);
2657 return error_mark_node
;
2660 TREE_OPERAND (declarator
, 0) = fns
;
2663 /* Figure out what exactly is being specialized at this point.
2664 Note that for an explicit instantiation, even one for a
2665 member function, we cannot tell apriori whether the
2666 instantiation is for a member template, or just a member
2667 function of a template class. Even if a member template is
2668 being instantiated, the member template arguments may be
2669 elided if they can be deduced from the rest of the
2671 tmpl
= determine_specialization (declarator
, decl
,
2673 member_specialization
,
2677 if (!tmpl
|| tmpl
== error_mark_node
)
2678 /* We couldn't figure out what this declaration was
2680 return error_mark_node
;
2683 tree gen_tmpl
= most_general_template (tmpl
);
2685 if (explicit_instantiation
)
2687 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2688 is done by do_decl_instantiation later. */
2690 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2691 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2693 if (arg_depth
> parm_depth
)
2695 /* If TMPL is not the most general template (for
2696 example, if TMPL is a friend template that is
2697 injected into namespace scope), then there will
2698 be too many levels of TARGS. Remove some of them
2703 new_targs
= make_tree_vec (parm_depth
);
2704 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2705 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2706 = TREE_VEC_ELT (targs
, i
);
2710 return instantiate_template (tmpl
, targs
, tf_error
);
2713 /* If we thought that the DECL was a member function, but it
2714 turns out to be specializing a static member function,
2715 make DECL a static member function as well. */
2716 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2717 && DECL_STATIC_FUNCTION_P (tmpl
)
2718 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2719 revert_static_member_fn (decl
);
2721 /* If this is a specialization of a member template of a
2722 template class, we want to return the TEMPLATE_DECL, not
2723 the specialization of it. */
2724 if (tsk
== tsk_template
)
2726 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
2727 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2728 DECL_INITIAL (result
) = NULL_TREE
;
2732 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2733 DECL_SOURCE_LOCATION (result
)
2734 = DECL_SOURCE_LOCATION (decl
);
2735 /* We want to use the argument list specified in the
2736 definition, not in the original declaration. */
2737 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
2738 for (parm
= DECL_ARGUMENTS (result
); parm
;
2739 parm
= DECL_CHAIN (parm
))
2740 DECL_CONTEXT (parm
) = result
;
2742 return register_specialization (tmpl
, gen_tmpl
, targs
,
2746 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2747 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
2749 /* Inherit default function arguments from the template
2750 DECL is specializing. */
2751 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
2752 copy_default_args_to_explicit_spec (decl
);
2754 /* This specialization has the same protection as the
2755 template it specializes. */
2756 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2757 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2759 /* 7.1.1-1 [dcl.stc]
2761 A storage-class-specifier shall not be specified in an
2762 explicit specialization...
2764 The parser rejects these, so unless action is taken here,
2765 explicit function specializations will always appear with
2768 The action recommended by the C++ CWG in response to C++
2769 defect report 605 is to make the storage class and linkage
2770 of the explicit specialization match the templated function:
2772 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2774 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2776 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2777 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2779 /* This specialization has the same linkage and visibility as
2780 the function template it specializes. */
2781 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2782 if (! TREE_PUBLIC (decl
))
2784 DECL_INTERFACE_KNOWN (decl
) = 1;
2785 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2787 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2788 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2790 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2791 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2795 /* If DECL is a friend declaration, declared using an
2796 unqualified name, the namespace associated with DECL may
2797 have been set incorrectly. For example, in:
2799 template <typename T> void f(T);
2801 struct S { friend void f<int>(int); }
2804 we will have set the DECL_CONTEXT for the friend
2805 declaration to N, rather than to the global namespace. */
2806 if (DECL_NAMESPACE_SCOPE_P (decl
))
2807 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2809 if (is_friend
&& !have_def
)
2810 /* This is not really a declaration of a specialization.
2811 It's just the name of an instantiation. But, it's not
2812 a request for an instantiation, either. */
2813 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2814 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2815 /* A specialization is not necessarily COMDAT. */
2816 DECL_COMDAT (decl
) = DECL_DECLARED_INLINE_P (decl
);
2817 else if (TREE_CODE (decl
) == VAR_DECL
)
2818 DECL_COMDAT (decl
) = false;
2820 /* Register this specialization so that we can find it
2822 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
, 0);
2824 /* A 'structor should already have clones. */
2825 gcc_assert (decl
== error_mark_node
2826 || variable_template_p (tmpl
)
2827 || !(DECL_CONSTRUCTOR_P (decl
)
2828 || DECL_DESTRUCTOR_P (decl
))
2829 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
2836 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2837 parameters. These are represented in the same format used for
2838 DECL_TEMPLATE_PARMS. */
2841 comp_template_parms (const_tree parms1
, const_tree parms2
)
2846 if (parms1
== parms2
)
2849 for (p1
= parms1
, p2
= parms2
;
2850 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2851 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2853 tree t1
= TREE_VALUE (p1
);
2854 tree t2
= TREE_VALUE (p2
);
2857 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2858 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2860 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2863 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2865 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2866 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2868 /* If either of the template parameters are invalid, assume
2869 they match for the sake of error recovery. */
2870 if (error_operand_p (parm1
) || error_operand_p (parm2
))
2873 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2876 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2877 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2878 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2880 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2885 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2886 /* One set of parameters has more parameters lists than the
2893 /* Determine whether PARM is a parameter pack. */
2896 template_parameter_pack_p (const_tree parm
)
2898 /* Determine if we have a non-type template parameter pack. */
2899 if (TREE_CODE (parm
) == PARM_DECL
)
2900 return (DECL_TEMPLATE_PARM_P (parm
)
2901 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2902 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
2903 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
2905 /* If this is a list of template parameters, we could get a
2906 TYPE_DECL or a TEMPLATE_DECL. */
2907 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2908 parm
= TREE_TYPE (parm
);
2910 /* Otherwise it must be a type template parameter. */
2911 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2912 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2913 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2916 /* Determine if T is a function parameter pack. */
2919 function_parameter_pack_p (const_tree t
)
2921 if (t
&& TREE_CODE (t
) == PARM_DECL
)
2922 return DECL_PACK_P (t
);
2926 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2927 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2930 get_function_template_decl (const_tree primary_func_tmpl_inst
)
2932 if (! primary_func_tmpl_inst
2933 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
2934 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
2937 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
2940 /* Return true iff the function parameter PARAM_DECL was expanded
2941 from the function parameter pack PACK. */
2944 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
2946 if (DECL_ARTIFICIAL (param_decl
)
2947 || !function_parameter_pack_p (pack
))
2950 /* The parameter pack and its pack arguments have the same
2952 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
2955 /* Determine whether ARGS describes a variadic template args list,
2956 i.e., one that is terminated by a template argument pack. */
2959 template_args_variadic_p (tree args
)
2964 if (args
== NULL_TREE
)
2967 args
= INNERMOST_TEMPLATE_ARGS (args
);
2968 nargs
= TREE_VEC_LENGTH (args
);
2973 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2975 return ARGUMENT_PACK_P (last_parm
);
2978 /* Generate a new name for the parameter pack name NAME (an
2979 IDENTIFIER_NODE) that incorporates its */
2982 make_ith_pack_parameter_name (tree name
, int i
)
2984 /* Munge the name to include the parameter index. */
2985 #define NUMBUF_LEN 128
2986 char numbuf
[NUMBUF_LEN
];
2990 if (name
== NULL_TREE
)
2992 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
2993 newname_len
= IDENTIFIER_LENGTH (name
)
2994 + strlen (numbuf
) + 2;
2995 newname
= (char*)alloca (newname_len
);
2996 snprintf (newname
, newname_len
,
2997 "%s#%i", IDENTIFIER_POINTER (name
), i
);
2998 return get_identifier (newname
);
3001 /* Return true if T is a primary function, class or alias template
3005 primary_template_instantiation_p (const_tree t
)
3010 if (TREE_CODE (t
) == FUNCTION_DECL
)
3011 return DECL_LANG_SPECIFIC (t
)
3012 && DECL_TEMPLATE_INSTANTIATION (t
)
3013 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
3014 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3015 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
3016 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
3017 else if (alias_template_specialization_p (t
))
3022 /* Return true if PARM is a template template parameter. */
3025 template_template_parameter_p (const_tree parm
)
3027 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3030 /* Return true iff PARM is a DECL representing a type template
3034 template_type_parameter_p (const_tree parm
)
3037 && (TREE_CODE (parm
) == TYPE_DECL
3038 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3039 && DECL_TEMPLATE_PARM_P (parm
));
3042 /* Return the template parameters of T if T is a
3043 primary template instantiation, NULL otherwise. */
3046 get_primary_template_innermost_parameters (const_tree t
)
3048 tree parms
= NULL
, template_info
= NULL
;
3050 if ((template_info
= get_template_info (t
))
3051 && primary_template_instantiation_p (t
))
3052 parms
= INNERMOST_TEMPLATE_PARMS
3053 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3058 /* Return the template parameters of the LEVELth level from the full list
3059 of template parameters PARMS. */
3062 get_template_parms_at_level (tree parms
, int level
)
3066 || TREE_CODE (parms
) != TREE_LIST
3067 || level
> TMPL_PARMS_DEPTH (parms
))
3070 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3071 if (TMPL_PARMS_DEPTH (p
) == level
)
3077 /* Returns the template arguments of T if T is a template instantiation,
3081 get_template_innermost_arguments (const_tree t
)
3083 tree args
= NULL
, template_info
= NULL
;
3085 if ((template_info
= get_template_info (t
))
3086 && TI_ARGS (template_info
))
3087 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3092 /* Return the argument pack elements of T if T is a template argument pack,
3096 get_template_argument_pack_elems (const_tree t
)
3098 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3099 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3102 return ARGUMENT_PACK_ARGS (t
);
3105 /* Structure used to track the progress of find_parameter_packs_r. */
3106 struct find_parameter_pack_data
3108 /* TREE_LIST that will contain all of the parameter packs found by
3110 tree
* parameter_packs
;
3112 /* Set of AST nodes that have been visited by the traversal. */
3113 hash_set
<tree
> *visited
;
3116 /* Identifies all of the argument packs that occur in a template
3117 argument and appends them to the TREE_LIST inside DATA, which is a
3118 find_parameter_pack_data structure. This is a subroutine of
3119 make_pack_expansion and uses_parameter_packs. */
3121 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3124 struct find_parameter_pack_data
* ppd
=
3125 (struct find_parameter_pack_data
*)data
;
3126 bool parameter_pack_p
= false;
3128 /* Handle type aliases/typedefs. */
3129 if (TYPE_ALIAS_P (t
))
3131 if (TYPE_TEMPLATE_INFO (t
))
3132 cp_walk_tree (&TYPE_TI_ARGS (t
),
3133 &find_parameter_packs_r
,
3139 /* Identify whether this is a parameter pack or not. */
3140 switch (TREE_CODE (t
))
3142 case TEMPLATE_PARM_INDEX
:
3143 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3144 parameter_pack_p
= true;
3147 case TEMPLATE_TYPE_PARM
:
3148 t
= TYPE_MAIN_VARIANT (t
);
3149 case TEMPLATE_TEMPLATE_PARM
:
3150 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3151 parameter_pack_p
= true;
3156 if (DECL_PACK_P (t
))
3158 /* We don't want to walk into the type of a PARM_DECL,
3159 because we don't want to see the type parameter pack. */
3161 parameter_pack_p
= true;
3165 /* Look through a lambda capture proxy to the field pack. */
3167 if (DECL_HAS_VALUE_EXPR_P (t
))
3169 tree v
= DECL_VALUE_EXPR (t
);
3171 &find_parameter_packs_r
,
3178 parameter_pack_p
= true;
3181 /* Not a parameter pack. */
3185 if (parameter_pack_p
)
3187 /* Add this parameter pack to the list. */
3188 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3192 cp_walk_tree (&TYPE_CONTEXT (t
),
3193 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3195 /* This switch statement will return immediately if we don't find a
3197 switch (TREE_CODE (t
))
3199 case TEMPLATE_PARM_INDEX
:
3202 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3203 /* Check the template itself. */
3204 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3205 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3206 /* Check the template arguments. */
3207 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3212 case TEMPLATE_TYPE_PARM
:
3213 case TEMPLATE_TEMPLATE_PARM
:
3220 if (TYPE_PTRMEMFUNC_P (t
))
3226 if (TYPE_TEMPLATE_INFO (t
))
3227 cp_walk_tree (&TYPE_TI_ARGS (t
),
3228 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3235 cp_walk_tree (&TREE_TYPE (t
),
3236 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3240 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3245 case TYPE_PACK_EXPANSION
:
3246 case EXPR_PACK_EXPANSION
:
3251 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3256 case IDENTIFIER_NODE
:
3257 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3269 /* Determines if the expression or type T uses any parameter packs. */
3271 uses_parameter_packs (tree t
)
3273 tree parameter_packs
= NULL_TREE
;
3274 struct find_parameter_pack_data ppd
;
3275 ppd
.parameter_packs
= ¶meter_packs
;
3276 ppd
.visited
= new hash_set
<tree
>;
3277 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3279 return parameter_packs
!= NULL_TREE
;
3282 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3283 representation a base-class initializer into a parameter pack
3284 expansion. If all goes well, the resulting node will be an
3285 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3288 make_pack_expansion (tree arg
)
3291 tree parameter_packs
= NULL_TREE
;
3292 bool for_types
= false;
3293 struct find_parameter_pack_data ppd
;
3295 if (!arg
|| arg
== error_mark_node
)
3298 if (TREE_CODE (arg
) == TREE_LIST
)
3300 /* The only time we will see a TREE_LIST here is for a base
3301 class initializer. In this case, the TREE_PURPOSE will be a
3302 _TYPE node (representing the base class expansion we're
3303 initializing) and the TREE_VALUE will be a TREE_LIST
3304 containing the initialization arguments.
3306 The resulting expansion looks somewhat different from most
3307 expansions. Rather than returning just one _EXPANSION, we
3308 return a TREE_LIST whose TREE_PURPOSE is a
3309 TYPE_PACK_EXPANSION containing the bases that will be
3310 initialized. The TREE_VALUE will be identical to the
3311 original TREE_VALUE, which is a list of arguments that will
3312 be passed to each base. We do not introduce any new pack
3313 expansion nodes into the TREE_VALUE (although it is possible
3314 that some already exist), because the TREE_PURPOSE and
3315 TREE_VALUE all need to be expanded together with the same
3316 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3317 resulting TREE_PURPOSE will mention the parameter packs in
3318 both the bases and the arguments to the bases. */
3321 tree parameter_packs
= NULL_TREE
;
3323 /* Determine which parameter packs will be used by the base
3325 ppd
.visited
= new hash_set
<tree
>;
3326 ppd
.parameter_packs
= ¶meter_packs
;
3327 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3330 if (parameter_packs
== NULL_TREE
)
3332 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
3334 return error_mark_node
;
3337 if (TREE_VALUE (arg
) != void_type_node
)
3339 /* Collect the sets of parameter packs used in each of the
3340 initialization arguments. */
3341 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3343 /* Determine which parameter packs will be expanded in this
3345 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3352 /* Create the pack expansion type for the base type. */
3353 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3354 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3355 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3357 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3358 they will rarely be compared to anything. */
3359 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3361 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3364 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3367 /* Build the PACK_EXPANSION_* node. */
3369 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3370 : make_node (EXPR_PACK_EXPANSION
);
3371 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3372 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3374 /* Propagate type and const-expression information. */
3375 TREE_TYPE (result
) = TREE_TYPE (arg
);
3376 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3379 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3380 they will rarely be compared to anything. */
3381 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3383 /* Determine which parameter packs will be expanded. */
3384 ppd
.parameter_packs
= ¶meter_packs
;
3385 ppd
.visited
= new hash_set
<tree
>;
3386 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3389 /* Make sure we found some parameter packs. */
3390 if (parameter_packs
== NULL_TREE
)
3393 error ("expansion pattern %<%T%> contains no argument packs", arg
);
3395 error ("expansion pattern %<%E%> contains no argument packs", arg
);
3396 return error_mark_node
;
3398 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3400 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3405 /* Checks T for any "bare" parameter packs, which have not yet been
3406 expanded, and issues an error if any are found. This operation can
3407 only be done on full expressions or types (e.g., an expression
3408 statement, "if" condition, etc.), because we could have expressions like:
3410 foo(f(g(h(args)))...)
3412 where "args" is a parameter pack. check_for_bare_parameter_packs
3413 should not be called for the subexpressions args, h(args),
3414 g(h(args)), or f(g(h(args))), because we would produce erroneous
3417 Returns TRUE and emits an error if there were bare parameter packs,
3418 returns FALSE otherwise. */
3420 check_for_bare_parameter_packs (tree t
)
3422 tree parameter_packs
= NULL_TREE
;
3423 struct find_parameter_pack_data ppd
;
3425 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3428 if (TREE_CODE (t
) == TYPE_DECL
)
3431 ppd
.parameter_packs
= ¶meter_packs
;
3432 ppd
.visited
= new hash_set
<tree
>;
3433 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3436 if (parameter_packs
)
3438 error ("parameter packs not expanded with %<...%>:");
3439 while (parameter_packs
)
3441 tree pack
= TREE_VALUE (parameter_packs
);
3442 tree name
= NULL_TREE
;
3444 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3445 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3446 name
= TYPE_NAME (pack
);
3447 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3448 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3450 name
= DECL_NAME (pack
);
3453 inform (input_location
, " %qD", name
);
3455 inform (input_location
, " <anonymous>");
3457 parameter_packs
= TREE_CHAIN (parameter_packs
);
3466 /* Expand any parameter packs that occur in the template arguments in
3469 expand_template_argument_pack (tree args
)
3471 tree result_args
= NULL_TREE
;
3472 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3473 int num_result_args
= -1;
3474 int non_default_args_count
= -1;
3476 /* First, determine if we need to expand anything, and the number of
3477 slots we'll need. */
3478 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3480 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3481 if (arg
== NULL_TREE
)
3483 if (ARGUMENT_PACK_P (arg
))
3485 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3486 if (num_result_args
< 0)
3487 num_result_args
= in_arg
+ num_packed
;
3489 num_result_args
+= num_packed
;
3493 if (num_result_args
>= 0)
3498 /* If no expansion is necessary, we're done. */
3499 if (num_result_args
< 0)
3502 /* Expand arguments. */
3503 result_args
= make_tree_vec (num_result_args
);
3504 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3505 non_default_args_count
=
3506 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3507 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3509 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3510 if (ARGUMENT_PACK_P (arg
))
3512 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3513 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3514 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3515 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3516 if (non_default_args_count
> 0)
3517 non_default_args_count
+= num_packed
- 1;
3521 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3525 if (non_default_args_count
>= 0)
3526 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3530 /* Checks if DECL shadows a template parameter.
3532 [temp.local]: A template-parameter shall not be redeclared within its
3533 scope (including nested scopes).
3535 Emits an error and returns TRUE if the DECL shadows a parameter,
3536 returns FALSE otherwise. */
3539 check_template_shadow (tree decl
)
3543 /* If we're not in a template, we can't possibly shadow a template
3545 if (!current_template_parms
)
3548 /* Figure out what we're shadowing. */
3549 if (TREE_CODE (decl
) == OVERLOAD
)
3550 decl
= OVL_CURRENT (decl
);
3551 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
3553 /* If there's no previous binding for this name, we're not shadowing
3554 anything, let alone a template parameter. */
3558 /* If we're not shadowing a template parameter, we're done. Note
3559 that OLDDECL might be an OVERLOAD (or perhaps even an
3560 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3562 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
3565 /* We check for decl != olddecl to avoid bogus errors for using a
3566 name inside a class. We check TPFI to avoid duplicate errors for
3567 inline member templates. */
3569 || (DECL_TEMPLATE_PARM_P (decl
)
3570 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
3573 /* Don't complain about the injected class name, as we've already
3574 complained about the class itself. */
3575 if (DECL_SELF_REFERENCE_P (decl
))
3578 error ("declaration of %q+#D", decl
);
3579 error (" shadows template parm %q+#D", olddecl
);
3583 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3584 ORIG_LEVEL, DECL, and TYPE. */
3587 build_template_parm_index (int index
,
3593 tree t
= make_node (TEMPLATE_PARM_INDEX
);
3594 TEMPLATE_PARM_IDX (t
) = index
;
3595 TEMPLATE_PARM_LEVEL (t
) = level
;
3596 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
3597 TEMPLATE_PARM_DECL (t
) = decl
;
3598 TREE_TYPE (t
) = type
;
3599 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
3600 TREE_READONLY (t
) = TREE_READONLY (decl
);
3605 /* Find the canonical type parameter for the given template type
3606 parameter. Returns the canonical type parameter, which may be TYPE
3607 if no such parameter existed. */
3610 canonical_type_parameter (tree type
)
3613 int idx
= TEMPLATE_TYPE_IDX (type
);
3614 if (!canonical_template_parms
)
3615 vec_alloc (canonical_template_parms
, idx
+1);
3617 while (canonical_template_parms
->length () <= (unsigned)idx
)
3618 vec_safe_push (canonical_template_parms
, NULL_TREE
);
3620 list
= (*canonical_template_parms
)[idx
];
3621 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
3622 list
= TREE_CHAIN (list
);
3625 return TREE_VALUE (list
);
3628 (*canonical_template_parms
)[idx
]
3629 = tree_cons (NULL_TREE
, type
,
3630 (*canonical_template_parms
)[idx
]);
3635 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3636 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3637 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3638 new one is created. */
3641 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
3642 tsubst_flags_t complain
)
3644 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
3645 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
3646 != TEMPLATE_PARM_LEVEL (index
) - levels
)
3647 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
3649 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
3652 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
3653 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
3654 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
3655 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
3656 DECL_ARTIFICIAL (decl
) = 1;
3657 SET_DECL_TEMPLATE_PARM_P (decl
);
3659 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
3660 TEMPLATE_PARM_LEVEL (index
) - levels
,
3661 TEMPLATE_PARM_ORIG_LEVEL (index
),
3663 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
3664 TEMPLATE_PARM_PARAMETER_PACK (t
)
3665 = TEMPLATE_PARM_PARAMETER_PACK (index
);
3667 /* Template template parameters need this. */
3668 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
3669 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
3670 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
3674 return TEMPLATE_PARM_DESCENDANTS (index
);
3677 /* Process information from new template parameter PARM and append it
3678 to the LIST being built. This new parameter is a non-type
3679 parameter iff IS_NON_TYPE is true. This new parameter is a
3680 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3684 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
3685 bool is_non_type
, bool is_parameter_pack
)
3691 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
3692 defval
= TREE_PURPOSE (parm
);
3696 tree p
= tree_last (list
);
3698 if (p
&& TREE_VALUE (p
) != error_mark_node
)
3701 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
3702 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
3704 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
3712 parm
= TREE_VALUE (parm
);
3714 SET_DECL_TEMPLATE_PARM_P (parm
);
3716 if (TREE_TYPE (parm
) != error_mark_node
)
3720 The top-level cv-qualifiers on the template-parameter are
3721 ignored when determining its type. */
3722 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3723 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3724 TREE_TYPE (parm
) = error_mark_node
;
3725 else if (uses_parameter_packs (TREE_TYPE (parm
))
3726 && !is_parameter_pack
3727 /* If we're in a nested template parameter list, the template
3728 template parameter could be a parameter pack. */
3729 && processing_template_parmlist
== 1)
3731 /* This template parameter is not a parameter pack, but it
3732 should be. Complain about "bare" parameter packs. */
3733 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3735 /* Recover by calling this a parameter pack. */
3736 is_parameter_pack
= true;
3740 /* A template parameter is not modifiable. */
3741 TREE_CONSTANT (parm
) = 1;
3742 TREE_READONLY (parm
) = 1;
3743 decl
= build_decl (parm_loc
,
3744 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3745 TREE_CONSTANT (decl
) = 1;
3746 TREE_READONLY (decl
) = 1;
3747 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3748 = build_template_parm_index (idx
, processing_template_decl
,
3749 processing_template_decl
,
3750 decl
, TREE_TYPE (parm
));
3752 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3753 = is_parameter_pack
;
3758 parm
= TREE_VALUE (TREE_VALUE (parm
));
3760 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3762 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
3763 /* This is for distinguishing between real templates and template
3764 template parameters */
3765 TREE_TYPE (parm
) = t
;
3766 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3771 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
3772 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3773 decl
= build_decl (parm_loc
,
3774 TYPE_DECL
, parm
, t
);
3777 TYPE_NAME (t
) = decl
;
3778 TYPE_STUB_DECL (t
) = decl
;
3780 TEMPLATE_TYPE_PARM_INDEX (t
)
3781 = build_template_parm_index (idx
, processing_template_decl
,
3782 processing_template_decl
,
3783 decl
, TREE_TYPE (parm
));
3784 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3785 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3787 DECL_ARTIFICIAL (decl
) = 1;
3788 SET_DECL_TEMPLATE_PARM_P (decl
);
3790 parm
= build_tree_list (defval
, parm
);
3791 return chainon (list
, parm
);
3794 /* The end of a template parameter list has been reached. Process the
3795 tree list into a parameter vector, converting each parameter into a more
3796 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3800 end_template_parm_list (tree parms
)
3804 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3806 current_template_parms
3807 = tree_cons (size_int (processing_template_decl
),
3808 saved_parmlist
, current_template_parms
);
3810 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3812 next
= TREE_CHAIN (parm
);
3813 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3814 TREE_CHAIN (parm
) = NULL_TREE
;
3817 --processing_template_parmlist
;
3819 return saved_parmlist
;
3822 /* end_template_decl is called after a template declaration is seen. */
3825 end_template_decl (void)
3827 reset_specialization ();
3829 if (! processing_template_decl
)
3832 /* This matches the pushlevel in begin_template_parm_list. */
3835 --processing_template_decl
;
3836 current_template_parms
= TREE_CHAIN (current_template_parms
);
3839 /* Takes a TREE_LIST representing a template parameter and convert it
3840 into an argument suitable to be passed to the type substitution
3841 functions. Note that If the TREE_LIST contains an error_mark
3842 node, the returned argument is error_mark_node. */
3845 template_parm_to_arg (tree t
)
3849 || TREE_CODE (t
) != TREE_LIST
)
3852 if (error_operand_p (TREE_VALUE (t
)))
3853 return error_mark_node
;
3857 if (TREE_CODE (t
) == TYPE_DECL
3858 || TREE_CODE (t
) == TEMPLATE_DECL
)
3862 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3864 /* Turn this argument into a TYPE_ARGUMENT_PACK
3865 with a single element, which expands T. */
3866 tree vec
= make_tree_vec (1);
3867 #ifdef ENABLE_CHECKING
3868 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3869 (vec
, TREE_VEC_LENGTH (vec
));
3871 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3873 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
3874 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3879 t
= DECL_INITIAL (t
);
3881 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3883 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3884 with a single element, which expands T. */
3885 tree vec
= make_tree_vec (1);
3886 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3887 #ifdef ENABLE_CHECKING
3888 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3889 (vec
, TREE_VEC_LENGTH (vec
));
3891 t
= convert_from_reference (t
);
3892 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3894 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3895 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3896 TREE_TYPE (t
) = type
;
3899 t
= convert_from_reference (t
);
3904 /* Given a set of template parameters, return them as a set of template
3905 arguments. The template parameters are represented as a TREE_VEC, in
3906 the form documented in cp-tree.h for template arguments. */
3909 template_parms_to_args (tree parms
)
3912 tree args
= NULL_TREE
;
3913 int length
= TMPL_PARMS_DEPTH (parms
);
3916 /* If there is only one level of template parameters, we do not
3917 create a TREE_VEC of TREE_VECs. Instead, we return a single
3918 TREE_VEC containing the arguments. */
3920 args
= make_tree_vec (length
);
3922 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
3924 tree a
= copy_node (TREE_VALUE (header
));
3927 TREE_TYPE (a
) = NULL_TREE
;
3928 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3929 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
3931 #ifdef ENABLE_CHECKING
3932 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
3936 TREE_VEC_ELT (args
, --l
) = a
;
3941 if (length
> 1 && TREE_VEC_ELT (args
, 0) == NULL_TREE
)
3942 /* This can happen for template parms of a template template
3945 template<template<class T, class U> class TT> struct S;
3947 Consider the level of the parms of TT; T and U both have
3948 level 2; TT has no template parm of level 1. So in this case
3949 the first element of full_template_args is NULL_TREE. If we
3950 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3951 of 2. This will make tsubst wrongly consider that T and U
3952 have level 1. Instead, let's create a dummy vector as the
3953 first element of full_template_args so that TMPL_ARGS_DEPTH
3954 returns the correct depth for args. */
3955 TREE_VEC_ELT (args
, 0) = make_tree_vec (1);
3959 /* Within the declaration of a template, return the currently active
3960 template parameters as an argument TREE_VEC. */
3963 current_template_args (void)
3965 return template_parms_to_args (current_template_parms
);
3968 /* Update the declared TYPE by doing any lookups which were thought to be
3969 dependent, but are not now that we know the SCOPE of the declarator. */
3972 maybe_update_decl_type (tree orig_type
, tree scope
)
3974 tree type
= orig_type
;
3976 if (type
== NULL_TREE
)
3979 if (TREE_CODE (orig_type
) == TYPE_DECL
)
3980 type
= TREE_TYPE (type
);
3982 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
3983 && dependent_type_p (type
)
3984 /* Don't bother building up the args in this case. */
3985 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
3987 /* tsubst in the args corresponding to the template parameters,
3988 including auto if present. Most things will be unchanged, but
3989 make_typename_type and tsubst_qualified_id will resolve
3990 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3991 tree args
= current_template_args ();
3992 tree auto_node
= type_uses_auto (type
);
3996 tree auto_vec
= make_tree_vec (1);
3997 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
3998 args
= add_to_template_args (args
, auto_vec
);
4000 pushed
= push_scope (scope
);
4001 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4006 if (type
== error_mark_node
)
4009 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4011 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4014 type
= TYPE_NAME (type
);
4019 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4020 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
4021 a member template. Used by push_template_decl below. */
4024 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4026 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4027 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4028 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4029 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4030 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4035 struct template_parm_data
4037 /* The level of the template parameters we are currently
4041 /* The index of the specialization argument we are currently
4045 /* An array whose size is the number of template parameters. The
4046 elements are nonzero if the parameter has been used in any one
4047 of the arguments processed so far. */
4050 /* An array whose size is the number of template arguments. The
4051 elements are nonzero if the argument makes use of template
4052 parameters of this level. */
4053 int* arg_uses_template_parms
;
4056 /* Subroutine of push_template_decl used to see if each template
4057 parameter in a partial specialization is used in the explicit
4058 argument list. If T is of the LEVEL given in DATA (which is
4059 treated as a template_parm_data*), then DATA->PARMS is marked
4063 mark_template_parm (tree t
, void* data
)
4067 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4069 template_parm_level_and_index (t
, &level
, &idx
);
4071 if (level
== tpd
->level
)
4073 tpd
->parms
[idx
] = 1;
4074 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4077 /* Return zero so that for_each_template_parm will continue the
4078 traversal of the tree; we want to mark *every* template parm. */
4082 /* Process the partial specialization DECL. */
4085 process_partial_specialization (tree decl
)
4087 tree type
= TREE_TYPE (decl
);
4088 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
4089 tree specargs
= CLASSTYPE_TI_ARGS (type
);
4090 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4091 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4094 int nargs
= TREE_VEC_LENGTH (inner_args
);
4097 bool did_error_intro
= false;
4098 struct template_parm_data tpd
;
4099 struct template_parm_data tpd2
;
4101 gcc_assert (current_template_parms
);
4103 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4104 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4106 /* We check that each of the template parameters given in the
4107 partial specialization is used in the argument list to the
4108 specialization. For example:
4110 template <class T> struct S;
4111 template <class T> struct S<T*>;
4113 The second declaration is OK because `T*' uses the template
4114 parameter T, whereas
4116 template <class T> struct S<int>;
4118 is no good. Even trickier is:
4129 The S2<T> declaration is actually invalid; it is a
4130 full-specialization. Of course,
4133 struct S2<T (*)(U)>;
4135 or some such would have been OK. */
4136 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4137 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4138 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4140 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4141 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4142 for (i
= 0; i
< nargs
; ++i
)
4144 tpd
.current_arg
= i
;
4145 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4146 &mark_template_parm
,
4149 /*include_nondeduced_p=*/false);
4151 for (i
= 0; i
< ntparms
; ++i
)
4152 if (tpd
.parms
[i
] == 0)
4154 /* One of the template parms was not used in a deduced context in the
4156 if (!did_error_intro
)
4158 error ("template parameters not deducible in "
4159 "partial specialization:");
4160 did_error_intro
= true;
4163 inform (input_location
, " %qD",
4164 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4167 if (did_error_intro
)
4168 return error_mark_node
;
4170 /* [temp.class.spec]
4172 The argument list of the specialization shall not be identical to
4173 the implicit argument list of the primary template. */
4174 if (comp_template_args
4176 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
4178 error ("partial specialization %qT does not specialize any template arguments", type
);
4180 /* A partial specialization that replaces multiple parameters of the
4181 primary template with a pack expansion is less specialized for those
4183 if (nargs
< DECL_NTPARMS (maintmpl
))
4185 error ("partial specialization is not more specialized than the "
4186 "primary template because it replaces multiple parameters "
4187 "with a pack expansion");
4188 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4192 /* [temp.class.spec]
4194 A partially specialized non-type argument expression shall not
4195 involve template parameters of the partial specialization except
4196 when the argument expression is a simple identifier.
4198 The type of a template parameter corresponding to a specialized
4199 non-type argument shall not be dependent on a parameter of the
4202 Also, we verify that pack expansions only occur at the
4203 end of the argument list. */
4204 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4206 for (i
= 0; i
< nargs
; ++i
)
4208 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4209 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4210 tree packed_args
= NULL_TREE
;
4213 if (ARGUMENT_PACK_P (arg
))
4215 /* Extract the arguments from the argument pack. We'll be
4216 iterating over these in the following loop. */
4217 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4218 len
= TREE_VEC_LENGTH (packed_args
);
4221 for (j
= 0; j
< len
; j
++)
4224 /* Get the Jth argument in the parameter pack. */
4225 arg
= TREE_VEC_ELT (packed_args
, j
);
4227 if (PACK_EXPANSION_P (arg
))
4229 /* Pack expansions must come at the end of the
4231 if ((packed_args
&& j
< len
- 1)
4232 || (!packed_args
&& i
< nargs
- 1))
4234 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4235 error ("parameter pack argument %qE must be at the "
4236 "end of the template argument list", arg
);
4238 error ("parameter pack argument %qT must be at the "
4239 "end of the template argument list", arg
);
4243 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4244 /* We only care about the pattern. */
4245 arg
= PACK_EXPANSION_PATTERN (arg
);
4247 if (/* These first two lines are the `non-type' bit. */
4249 && TREE_CODE (arg
) != TEMPLATE_DECL
4250 /* This next two lines are the `argument expression is not just a
4251 simple identifier' condition and also the `specialized
4252 non-type argument' bit. */
4253 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4254 && !(REFERENCE_REF_P (arg
)
4255 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4257 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4258 || (packed_args
&& uses_template_parms (arg
)))
4259 error ("template argument %qE involves template parameter(s)",
4263 /* Look at the corresponding template parameter,
4264 marking which template parameters its type depends
4266 tree type
= TREE_TYPE (parm
);
4270 /* We haven't yet initialized TPD2. Do so now. */
4271 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4272 /* The number of parameters here is the number in the
4273 main template, which, as checked in the assertion
4275 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4277 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4280 /* Mark the template parameters. But this time, we're
4281 looking for the template parameters of the main
4282 template, not in the specialization. */
4283 tpd2
.current_arg
= i
;
4284 tpd2
.arg_uses_template_parms
[i
] = 0;
4285 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4286 for_each_template_parm (type
,
4287 &mark_template_parm
,
4290 /*include_nondeduced_p=*/false);
4292 if (tpd2
.arg_uses_template_parms
[i
])
4294 /* The type depended on some template parameters.
4295 If they are fully specialized in the
4296 specialization, that's OK. */
4299 for (j
= 0; j
< nargs
; ++j
)
4300 if (tpd2
.parms
[j
] != 0
4301 && tpd
.arg_uses_template_parms
[j
])
4304 error_n (input_location
, count
,
4305 "type %qT of template argument %qE depends "
4306 "on a template parameter",
4307 "type %qT of template argument %qE depends "
4308 "on template parameters",
4317 /* We should only get here once. */
4318 gcc_assert (!COMPLETE_TYPE_P (type
));
4320 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4321 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4322 TREE_TYPE (tmpl
) = type
;
4323 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4324 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4325 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4326 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4328 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4329 = tree_cons (specargs
, tmpl
,
4330 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4331 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4333 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4334 inst
= TREE_CHAIN (inst
))
4336 tree inst_type
= TREE_VALUE (inst
);
4337 if (COMPLETE_TYPE_P (inst_type
)
4338 && CLASSTYPE_IMPLICIT_INSTANTIATION (inst_type
))
4340 tree spec
= most_specialized_class (inst_type
, tf_none
);
4341 if (spec
&& TREE_TYPE (spec
) == type
)
4342 permerror (input_location
,
4343 "partial specialization of %qT after instantiation "
4344 "of %qT", type
, inst_type
);
4351 /* PARM is a template parameter of some form; return the corresponding
4352 TEMPLATE_PARM_INDEX. */
4355 get_template_parm_index (tree parm
)
4357 if (TREE_CODE (parm
) == PARM_DECL
4358 || TREE_CODE (parm
) == CONST_DECL
)
4359 parm
= DECL_INITIAL (parm
);
4360 else if (TREE_CODE (parm
) == TYPE_DECL
4361 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4362 parm
= TREE_TYPE (parm
);
4363 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4364 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4365 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4366 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4370 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4371 parameter packs used by the template parameter PARM. */
4374 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4376 /* A type parm can't refer to another parm. */
4377 if (TREE_CODE (parm
) == TYPE_DECL
)
4379 else if (TREE_CODE (parm
) == PARM_DECL
)
4381 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4386 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4388 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4389 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4390 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4393 /* PARM is a template parameter pack. Return any parameter packs used in
4394 its type or the type of any of its template parameters. If there are
4395 any such packs, it will be instantiated into a fixed template parameter
4396 list by partial instantiation rather than be fully deduced. */
4399 fixed_parameter_pack_p (tree parm
)
4401 /* This can only be true in a member template. */
4402 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4404 /* This can only be true for a parameter pack. */
4405 if (!template_parameter_pack_p (parm
))
4407 /* A type parm can't refer to another parm. */
4408 if (TREE_CODE (parm
) == TYPE_DECL
)
4411 tree parameter_packs
= NULL_TREE
;
4412 struct find_parameter_pack_data ppd
;
4413 ppd
.parameter_packs
= ¶meter_packs
;
4414 ppd
.visited
= new hash_set
<tree
>;
4416 fixed_parameter_pack_p_1 (parm
, &ppd
);
4419 return parameter_packs
;
4422 /* Check that a template declaration's use of default arguments and
4423 parameter packs is not invalid. Here, PARMS are the template
4424 parameters. IS_PRIMARY is true if DECL is the thing declared by
4425 a primary template. IS_PARTIAL is true if DECL is a partial
4428 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4429 declaration (but not a definition); 1 indicates a declaration, 2
4430 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4431 emitted for extraneous default arguments.
4433 Returns TRUE if there were no errors found, FALSE otherwise. */
4436 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4437 bool is_partial
, int is_friend_decl
)
4440 int last_level_to_check
;
4442 bool no_errors
= true;
4446 A default template-argument shall not be specified in a
4447 function template declaration or a function template definition, nor
4448 in the template-parameter-list of the definition of a member of a
4451 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
4452 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
4453 /* You can't have a function template declaration in a local
4454 scope, nor you can you define a member of a class template in a
4458 if (TREE_CODE (decl
) == TYPE_DECL
4460 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4461 /* A lambda doesn't have an explicit declaration; don't complain
4462 about the parms of the enclosing class. */
4465 if (current_class_type
4466 && !TYPE_BEING_DEFINED (current_class_type
)
4467 && DECL_LANG_SPECIFIC (decl
)
4468 && DECL_DECLARES_FUNCTION_P (decl
)
4469 /* If this is either a friend defined in the scope of the class
4470 or a member function. */
4471 && (DECL_FUNCTION_MEMBER_P (decl
)
4472 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
4473 : DECL_FRIEND_CONTEXT (decl
)
4474 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
4476 /* And, if it was a member function, it really was defined in
4477 the scope of the class. */
4478 && (!DECL_FUNCTION_MEMBER_P (decl
)
4479 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
4480 /* We already checked these parameters when the template was
4481 declared, so there's no need to do it again now. This function
4482 was defined in class scope, but we're processing its body now
4483 that the class is complete. */
4486 /* Core issue 226 (C++0x only): the following only applies to class
4489 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
4493 If a template-parameter has a default template-argument, all
4494 subsequent template-parameters shall have a default
4495 template-argument supplied. */
4496 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
4498 tree inner_parms
= TREE_VALUE (parm_level
);
4499 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
4500 int seen_def_arg_p
= 0;
4503 for (i
= 0; i
< ntparms
; ++i
)
4505 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
4507 if (parm
== error_mark_node
)
4510 if (TREE_PURPOSE (parm
))
4512 else if (seen_def_arg_p
4513 && !template_parameter_pack_p (TREE_VALUE (parm
)))
4515 error ("no default argument for %qD", TREE_VALUE (parm
));
4516 /* For better subsequent error-recovery, we indicate that
4517 there should have been a default argument. */
4518 TREE_PURPOSE (parm
) = error_mark_node
;
4521 else if (!is_partial
4523 /* Don't complain about an enclosing partial
4525 && parm_level
== parms
4526 && TREE_CODE (decl
) == TYPE_DECL
4528 && template_parameter_pack_p (TREE_VALUE (parm
))
4529 /* A fixed parameter pack will be partially
4530 instantiated into a fixed length list. */
4531 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
4533 /* A primary class template can only have one
4534 parameter pack, at the end of the template
4537 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
4538 error ("parameter pack %qE must be at the end of the"
4539 " template parameter list", TREE_VALUE (parm
));
4541 error ("parameter pack %qT must be at the end of the"
4542 " template parameter list",
4543 TREE_TYPE (TREE_VALUE (parm
)));
4545 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
4553 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
4557 /* For an ordinary class template, default template arguments are
4558 allowed at the innermost level, e.g.:
4559 template <class T = int>
4561 but, in a partial specialization, they're not allowed even
4562 there, as we have in [temp.class.spec]:
4564 The template parameter list of a specialization shall not
4565 contain default template argument values.
4567 So, for a partial specialization, or for a function template
4568 (in C++98/C++03), we look at all of them. */
4571 /* But, for a primary class template that is not a partial
4572 specialization we look at all template parameters except the
4574 parms
= TREE_CHAIN (parms
);
4576 /* Figure out what error message to issue. */
4577 if (is_friend_decl
== 2)
4578 msg
= G_("default template arguments may not be used in function template "
4579 "friend re-declaration");
4580 else if (is_friend_decl
)
4581 msg
= G_("default template arguments may not be used in function template "
4582 "friend declarations");
4583 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
4584 msg
= G_("default template arguments may not be used in function templates "
4585 "without -std=c++11 or -std=gnu++11");
4586 else if (is_partial
)
4587 msg
= G_("default template arguments may not be used in "
4588 "partial specializations");
4590 msg
= G_("default argument for template parameter for class enclosing %qD");
4592 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
4593 /* If we're inside a class definition, there's no need to
4594 examine the parameters to the class itself. On the one
4595 hand, they will be checked when the class is defined, and,
4596 on the other, default arguments are valid in things like:
4597 template <class T = double>
4598 struct S { template <class U> void f(U); };
4599 Here the default argument for `S' has no bearing on the
4600 declaration of `f'. */
4601 last_level_to_check
= template_class_depth (current_class_type
) + 1;
4603 /* Check everything. */
4604 last_level_to_check
= 0;
4606 for (parm_level
= parms
;
4607 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
4608 parm_level
= TREE_CHAIN (parm_level
))
4610 tree inner_parms
= TREE_VALUE (parm_level
);
4614 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4615 for (i
= 0; i
< ntparms
; ++i
)
4617 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
4620 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
4625 if (is_friend_decl
== 2)
4632 /* Clear out the default argument so that we are not
4634 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
4638 /* At this point, if we're still interested in issuing messages,
4639 they must apply to classes surrounding the object declared. */
4641 msg
= G_("default argument for template parameter for class "
4648 /* Worker for push_template_decl_real, called via
4649 for_each_template_parm. DATA is really an int, indicating the
4650 level of the parameters we are interested in. If T is a template
4651 parameter of that level, return nonzero. */
4654 template_parm_this_level_p (tree t
, void* data
)
4656 int this_level
= *(int *)data
;
4659 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4660 level
= TEMPLATE_PARM_LEVEL (t
);
4662 level
= TEMPLATE_TYPE_LEVEL (t
);
4663 return level
== this_level
;
4666 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4667 parameters given by current_template_args, or reuses a
4668 previously existing one, if appropriate. Returns the DECL, or an
4669 equivalent one, if it is replaced via a call to duplicate_decls.
4671 If IS_FRIEND is true, DECL is a friend declaration. */
4674 push_template_decl_real (tree decl
, bool is_friend
)
4682 int new_template_p
= 0;
4683 /* True if the template is a member template, in the sense of
4685 bool member_template_p
= false;
4687 if (decl
== error_mark_node
|| !current_template_parms
)
4688 return error_mark_node
;
4690 /* See if this is a partial specialization. */
4691 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
4692 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
4693 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
4695 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
4699 /* For a friend, we want the context of the friend function, not
4700 the type of which it is a friend. */
4701 ctx
= CP_DECL_CONTEXT (decl
);
4702 else if (CP_DECL_CONTEXT (decl
)
4703 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4704 /* In the case of a virtual function, we want the class in which
4706 ctx
= CP_DECL_CONTEXT (decl
);
4708 /* Otherwise, if we're currently defining some class, the DECL
4709 is assumed to be a member of the class. */
4710 ctx
= current_scope ();
4712 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
4715 if (!DECL_CONTEXT (decl
))
4716 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
4718 /* See if this is a primary template. */
4719 if (is_friend
&& ctx
4720 && uses_template_parms_level (ctx
, processing_template_decl
))
4721 /* A friend template that specifies a class context, i.e.
4722 template <typename T> friend void A<T>::f();
4725 else if (TREE_CODE (decl
) == TYPE_DECL
4726 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4729 is_primary
= template_parm_scope_p ();
4733 if (DECL_CLASS_SCOPE_P (decl
))
4734 member_template_p
= true;
4735 if (TREE_CODE (decl
) == TYPE_DECL
4736 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
4738 error ("template class without a name");
4739 return error_mark_node
;
4741 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
4743 if (member_template_p
)
4745 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
4746 error ("member template %qD may not have virt-specifiers", decl
);
4748 if (DECL_DESTRUCTOR_P (decl
))
4752 A destructor shall not be a member template. */
4753 error ("destructor %qD declared as member template", decl
);
4754 return error_mark_node
;
4756 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
4757 && (!prototype_p (TREE_TYPE (decl
))
4758 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
4759 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
4760 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
4761 == void_list_node
)))
4763 /* [basic.stc.dynamic.allocation]
4765 An allocation function can be a function
4766 template. ... Template allocation functions shall
4767 have two or more parameters. */
4768 error ("invalid template declaration of %qD", decl
);
4769 return error_mark_node
;
4772 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4773 && CLASS_TYPE_P (TREE_TYPE (decl
)))
4775 else if (TREE_CODE (decl
) == TYPE_DECL
4776 && TYPE_DECL_ALIAS_P (decl
))
4777 /* alias-declaration */
4778 gcc_assert (!DECL_ARTIFICIAL (decl
));
4779 else if (VAR_P (decl
))
4781 if (!DECL_DECLARED_CONSTEXPR_P (decl
))
4783 sorry ("template declaration of non-constexpr variable %qD",
4785 return error_mark_node
;
4790 error ("template declaration of %q#D", decl
);
4791 return error_mark_node
;
4795 /* Check to see that the rules regarding the use of default
4796 arguments are not being violated. */
4797 check_default_tmpl_args (decl
, current_template_parms
,
4798 is_primary
, is_partial
, /*is_friend_decl=*/0);
4800 /* Ensure that there are no parameter packs in the type of this
4801 declaration that have not been expanded. */
4802 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4804 /* Check each of the arguments individually to see if there are
4805 any bare parameter packs. */
4806 tree type
= TREE_TYPE (decl
);
4807 tree arg
= DECL_ARGUMENTS (decl
);
4808 tree argtype
= TYPE_ARG_TYPES (type
);
4810 while (arg
&& argtype
)
4812 if (!DECL_PACK_P (arg
)
4813 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
4815 /* This is a PARM_DECL that contains unexpanded parameter
4816 packs. We have already complained about this in the
4817 check_for_bare_parameter_packs call, so just replace
4818 these types with ERROR_MARK_NODE. */
4819 TREE_TYPE (arg
) = error_mark_node
;
4820 TREE_VALUE (argtype
) = error_mark_node
;
4823 arg
= DECL_CHAIN (arg
);
4824 argtype
= TREE_CHAIN (argtype
);
4827 /* Check for bare parameter packs in the return type and the
4828 exception specifiers. */
4829 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
4830 /* Errors were already issued, set return type to int
4831 as the frontend doesn't expect error_mark_node as
4833 TREE_TYPE (type
) = integer_type_node
;
4834 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
4835 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
4837 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
4838 && TYPE_DECL_ALIAS_P (decl
))
4839 ? DECL_ORIGINAL_TYPE (decl
)
4840 : TREE_TYPE (decl
)))
4842 TREE_TYPE (decl
) = error_mark_node
;
4843 return error_mark_node
;
4847 return process_partial_specialization (decl
);
4849 args
= current_template_args ();
4852 || TREE_CODE (ctx
) == FUNCTION_DECL
4853 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
4854 || (TREE_CODE (decl
) == TYPE_DECL
4855 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
4856 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
4858 if (DECL_LANG_SPECIFIC (decl
)
4859 && DECL_TEMPLATE_INFO (decl
)
4860 && DECL_TI_TEMPLATE (decl
))
4861 tmpl
= DECL_TI_TEMPLATE (decl
);
4862 /* If DECL is a TYPE_DECL for a class-template, then there won't
4863 be DECL_LANG_SPECIFIC. The information equivalent to
4864 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4865 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
4866 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
4867 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
4869 /* Since a template declaration already existed for this
4870 class-type, we must be redeclaring it here. Make sure
4871 that the redeclaration is valid. */
4872 redeclare_class_template (TREE_TYPE (decl
),
4873 current_template_parms
);
4874 /* We don't need to create a new TEMPLATE_DECL; just use the
4875 one we already had. */
4876 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
4880 tmpl
= build_template_decl (decl
, current_template_parms
,
4884 if (DECL_LANG_SPECIFIC (decl
)
4885 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4887 /* A specialization of a member template of a template
4889 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4890 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
4891 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
4897 tree a
, t
, current
, parms
;
4899 tree tinfo
= get_template_info (decl
);
4903 error ("template definition of non-template %q#D", decl
);
4904 return error_mark_node
;
4907 tmpl
= TI_TEMPLATE (tinfo
);
4909 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
4910 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
4911 && DECL_TEMPLATE_SPECIALIZATION (decl
)
4912 && DECL_MEMBER_TEMPLATE_P (tmpl
))
4916 /* The declaration is a specialization of a member
4917 template, declared outside the class. Therefore, the
4918 innermost template arguments will be NULL, so we
4919 replace them with the arguments determined by the
4920 earlier call to check_explicit_specialization. */
4921 args
= DECL_TI_ARGS (decl
);
4924 = build_template_decl (decl
, current_template_parms
,
4926 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
4927 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
4928 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
4929 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
4930 DECL_TEMPLATE_INFO (new_tmpl
)
4931 = build_template_info (tmpl
, args
);
4933 register_specialization (new_tmpl
,
4934 most_general_template (tmpl
),
4940 /* Make sure the template headers we got make sense. */
4942 parms
= DECL_TEMPLATE_PARMS (tmpl
);
4943 i
= TMPL_PARMS_DEPTH (parms
);
4944 if (TMPL_ARGS_DEPTH (args
) != i
)
4946 error ("expected %d levels of template parms for %q#D, got %d",
4947 i
, decl
, TMPL_ARGS_DEPTH (args
));
4948 DECL_INTERFACE_KNOWN (decl
) = 1;
4949 return error_mark_node
;
4952 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
4954 a
= TMPL_ARGS_LEVEL (args
, i
);
4955 t
= INNERMOST_TEMPLATE_PARMS (parms
);
4957 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
4959 if (current
== decl
)
4960 error ("got %d template parameters for %q#D",
4961 TREE_VEC_LENGTH (a
), decl
);
4963 error ("got %d template parameters for %q#T",
4964 TREE_VEC_LENGTH (a
), current
);
4965 error (" but %d required", TREE_VEC_LENGTH (t
));
4966 /* Avoid crash in import_export_decl. */
4967 DECL_INTERFACE_KNOWN (decl
) = 1;
4968 return error_mark_node
;
4971 if (current
== decl
)
4973 else if (current
== NULL_TREE
)
4974 /* Can happen in erroneous input. */
4977 current
= get_containing_scope (current
);
4980 /* Check that the parms are used in the appropriate qualifying scopes
4981 in the declarator. */
4982 if (!comp_template_args
4984 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4987 template arguments to %qD do not match original template %qD",
4988 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4989 if (!uses_template_parms (TI_ARGS (tinfo
)))
4990 inform (input_location
, "use template<> for an explicit specialization");
4991 /* Avoid crash in import_export_decl. */
4992 DECL_INTERFACE_KNOWN (decl
) = 1;
4993 return error_mark_node
;
4997 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4998 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5000 /* Push template declarations for global functions and types. Note
5001 that we do not try to push a global template friend declared in a
5002 template class; such a thing may well depend on the template
5003 parameters of the class. */
5004 if (new_template_p
&& !ctx
5005 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5007 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5008 if (tmpl
== error_mark_node
)
5009 return error_mark_node
;
5011 /* Hide template friend classes that haven't been declared yet. */
5012 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5014 DECL_ANTICIPATED (tmpl
) = 1;
5015 DECL_FRIEND_P (tmpl
) = 1;
5021 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5024 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5025 if (DECL_CONV_FN_P (tmpl
))
5027 int depth
= TMPL_PARMS_DEPTH (parms
);
5029 /* It is a conversion operator. See if the type converted to
5030 depends on innermost template operands. */
5032 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
5034 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
5037 /* Give template template parms a DECL_CONTEXT of the template
5038 for which they are a parameter. */
5039 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5040 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5042 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5043 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5044 DECL_CONTEXT (parm
) = tmpl
;
5048 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5049 back to its most general template. If TMPL is a specialization,
5050 ARGS may only have the innermost set of arguments. Add the missing
5051 argument levels if necessary. */
5052 if (DECL_TEMPLATE_INFO (tmpl
))
5053 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5055 info
= build_template_info (tmpl
, args
);
5057 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5058 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5061 if (is_primary
&& !DECL_LANG_SPECIFIC (decl
))
5062 retrofit_lang_decl (decl
);
5063 if (DECL_LANG_SPECIFIC (decl
))
5064 DECL_TEMPLATE_INFO (decl
) = info
;
5067 if (flag_implicit_templates
5069 && VAR_OR_FUNCTION_DECL_P (decl
))
5070 /* Set DECL_COMDAT on template instantiations; if we force
5071 them to be emitted by explicit instantiation or -frepo,
5072 mark_needed will tell cgraph to do the right thing. */
5073 DECL_COMDAT (decl
) = true;
5075 return DECL_TEMPLATE_RESULT (tmpl
);
5079 push_template_decl (tree decl
)
5081 return push_template_decl_real (decl
, false);
5084 /* FN is an inheriting constructor that inherits from the constructor
5085 template INHERITED; turn FN into a constructor template with a matching
5089 add_inherited_template_parms (tree fn
, tree inherited
)
5092 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5093 inner_parms
= copy_node (inner_parms
);
5095 = tree_cons (size_int (processing_template_decl
+ 1),
5096 inner_parms
, current_template_parms
);
5097 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5098 tree args
= template_parms_to_args (parms
);
5099 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5100 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5101 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5102 DECL_ARTIFICIAL (tmpl
) = true;
5103 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5107 /* Called when a class template TYPE is redeclared with the indicated
5108 template PARMS, e.g.:
5110 template <class T> struct S;
5111 template <class T> struct S {}; */
5114 redeclare_class_template (tree type
, tree parms
)
5120 if (!TYPE_TEMPLATE_INFO (type
))
5122 error ("%qT is not a template type", type
);
5126 tmpl
= TYPE_TI_TEMPLATE (type
);
5127 if (!PRIMARY_TEMPLATE_P (tmpl
))
5128 /* The type is nested in some template class. Nothing to worry
5129 about here; there are no new template parameters for the nested
5135 error ("template specifiers not specified in declaration of %qD",
5140 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5141 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5143 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5145 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5146 "redeclared with %d template parameter",
5147 "redeclared with %d template parameters",
5148 TREE_VEC_LENGTH (parms
));
5149 inform_n (input_location
, TREE_VEC_LENGTH (tmpl_parms
),
5150 "previous declaration %q+D used %d template parameter",
5151 "previous declaration %q+D used %d template parameters",
5152 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5156 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5163 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5164 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5167 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5168 if (error_operand_p (tmpl_parm
))
5171 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5172 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5173 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5175 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5177 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5178 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5179 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5180 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5181 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5182 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5183 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5184 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5185 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5187 error ("template parameter %q+#D", tmpl_parm
);
5188 error ("redeclared here as %q#D", parm
);
5192 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5194 /* We have in [temp.param]:
5196 A template-parameter may not be given default arguments
5197 by two different declarations in the same scope. */
5198 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5199 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5200 "original definition appeared here");
5204 if (parm_default
!= NULL_TREE
)
5205 /* Update the previous template parameters (which are the ones
5206 that will really count) with the new default value. */
5207 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5208 else if (tmpl_default
!= NULL_TREE
)
5209 /* Update the new parameters, too; they'll be used as the
5210 parameters for any members. */
5211 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5217 /* Simplify EXPR if it is a non-dependent expression. Returns the
5218 (possibly simplified) expression. */
5221 fold_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5223 if (expr
== NULL_TREE
)
5226 /* If we're in a template, but EXPR isn't value dependent, simplify
5227 it. We're supposed to treat:
5229 template <typename T> void f(T[1 + 1]);
5230 template <typename T> void f(T[2]);
5232 as two declarations of the same function, for example. */
5233 if (processing_template_decl
5234 && !instantiation_dependent_expression_p (expr
)
5235 && potential_constant_expression (expr
))
5237 HOST_WIDE_INT saved_processing_template_decl
;
5239 saved_processing_template_decl
= processing_template_decl
;
5240 processing_template_decl
= 0;
5241 expr
= tsubst_copy_and_build (expr
,
5244 /*in_decl=*/NULL_TREE
,
5245 /*function_p=*/false,
5246 /*integral_constant_expression_p=*/true);
5247 processing_template_decl
= saved_processing_template_decl
;
5253 fold_non_dependent_expr (tree expr
)
5255 return fold_non_dependent_expr_sfinae (expr
, tf_error
);
5258 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5259 template declaration, or a TYPE_DECL for an alias declaration. */
5262 alias_type_or_template_p (tree t
)
5266 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5269 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5270 || DECL_ALIAS_TEMPLATE_P (t
));
5273 /* Return TRUE iff is a specialization of an alias template. */
5276 alias_template_specialization_p (const_tree t
)
5282 && TYPE_TEMPLATE_INFO (t
)
5283 && PRIMARY_TEMPLATE_P (TYPE_TI_TEMPLATE (t
))
5284 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (t
)));
5287 /* Return the number of innermost template parameters in TMPL. */
5290 num_innermost_template_parms (tree tmpl
)
5292 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5293 return TREE_VEC_LENGTH (parms
);
5296 /* Return either TMPL or another template that it is equivalent to under DR
5297 1286: An alias that just changes the name of a template is equivalent to
5298 the other template. */
5301 get_underlying_template (tree tmpl
)
5303 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
5304 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
5306 tree result
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5307 if (TYPE_TEMPLATE_INFO (result
))
5309 tree sub
= TYPE_TI_TEMPLATE (result
);
5310 if (PRIMARY_TEMPLATE_P (sub
)
5311 && (num_innermost_template_parms (tmpl
)
5312 == num_innermost_template_parms (sub
)))
5314 tree alias_args
= INNERMOST_TEMPLATE_ARGS
5315 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
5316 if (!comp_template_args (TYPE_TI_ARGS (result
), alias_args
))
5318 /* The alias type is equivalent to the pattern of the
5319 underlying template, so strip the alias. */
5329 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5330 must be a function or a pointer-to-function type, as specified
5331 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5332 and check that the resulting function has external linkage. */
5335 convert_nontype_argument_function (tree type
, tree expr
,
5336 tsubst_flags_t complain
)
5340 linkage_kind linkage
;
5342 fn
= instantiate_type (type
, fns
, tf_none
);
5343 if (fn
== error_mark_node
)
5344 return error_mark_node
;
5347 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
5348 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
5349 if (BASELINK_P (fn_no_ptr
))
5350 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
5352 /* [temp.arg.nontype]/1
5354 A template-argument for a non-type, non-template template-parameter
5357 -- the address of an object or function with external [C++11: or
5358 internal] linkage. */
5360 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
5362 if (complain
& tf_error
)
5364 error ("%qE is not a valid template argument for type %qT",
5366 if (TYPE_PTR_P (type
))
5367 error ("it must be the address of a function with "
5368 "external linkage");
5370 error ("it must be the name of a function with "
5371 "external linkage");
5376 linkage
= decl_linkage (fn_no_ptr
);
5377 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
5379 if (complain
& tf_error
)
5381 if (cxx_dialect
>= cxx11
)
5382 error ("%qE is not a valid template argument for type %qT "
5383 "because %qD has no linkage",
5384 expr
, type
, fn_no_ptr
);
5386 error ("%qE is not a valid template argument for type %qT "
5387 "because %qD does not have external linkage",
5388 expr
, type
, fn_no_ptr
);
5396 /* Subroutine of convert_nontype_argument.
5397 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5398 Emit an error otherwise. */
5401 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
5402 tsubst_flags_t complain
)
5405 if (expr
&& (null_ptr_cst_p (expr
) || TREE_CODE (expr
) == PTRMEM_CST
))
5407 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
5409 if (processing_template_decl
5410 && TREE_CODE (expr
) == ADDR_EXPR
5411 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
5413 if (complain
& tf_error
)
5415 error ("%qE is not a valid template argument for type %qT",
5417 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5422 /* Returns TRUE iff the address of OP is value-dependent.
5424 14.6.2.4 [temp.dep.temp]:
5425 A non-integral non-type template-argument is dependent if its type is
5426 dependent or it has either of the following forms
5429 and contains a nested-name-specifier which specifies a class-name that
5430 names a dependent type.
5432 We generalize this to just say that the address of a member of a
5433 dependent class is value-dependent; the above doesn't cover the
5434 address of a static data member named with an unqualified-id. */
5437 has_value_dependent_address (tree op
)
5439 /* We could use get_inner_reference here, but there's no need;
5440 this is only relevant for template non-type arguments, which
5441 can only be expressed as &id-expression. */
5444 tree ctx
= CP_DECL_CONTEXT (op
);
5445 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
5452 /* The next set of functions are used for providing helpful explanatory
5453 diagnostics for failed overload resolution. Their messages should be
5454 indented by two spaces for consistency with the messages in
5458 unify_success (bool /*explain_p*/)
5464 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
5467 inform (input_location
,
5468 " couldn't deduce template parameter %qD", parm
);
5473 unify_invalid (bool /*explain_p*/)
5479 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
5482 inform (input_location
,
5483 " types %qT and %qT have incompatible cv-qualifiers",
5489 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
5492 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
5497 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
5500 inform (input_location
,
5501 " template parameter %qD is not a parameter pack, but "
5508 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
5511 inform (input_location
,
5512 " template argument %qE does not match "
5513 "pointer-to-member constant %qE",
5519 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
5522 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
5527 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
5530 inform (input_location
,
5531 " inconsistent parameter pack deduction with %qT and %qT",
5537 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
5542 inform (input_location
,
5543 " deduced conflicting types for parameter %qT (%qT and %qT)",
5544 parm
, first
, second
);
5546 inform (input_location
,
5547 " deduced conflicting values for non-type parameter "
5548 "%qE (%qE and %qE)", parm
, first
, second
);
5554 unify_vla_arg (bool explain_p
, tree arg
)
5557 inform (input_location
,
5558 " variable-sized array type %qT is not "
5559 "a valid template argument",
5565 unify_method_type_error (bool explain_p
, tree arg
)
5568 inform (input_location
,
5569 " member function type %qT is not a valid template argument",
5575 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
5580 inform_n (input_location
, wanted
,
5581 " candidate expects at least %d argument, %d provided",
5582 " candidate expects at least %d arguments, %d provided",
5585 inform_n (input_location
, wanted
,
5586 " candidate expects %d argument, %d provided",
5587 " candidate expects %d arguments, %d provided",
5594 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
5596 return unify_arity (explain_p
, have
, wanted
);
5600 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
5601 bool least_p
= false)
5603 return unify_arity (explain_p
, have
, wanted
, least_p
);
5607 unify_arg_conversion (bool explain_p
, tree to_type
,
5608 tree from_type
, tree arg
)
5611 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
5612 " cannot convert %qE (type %qT) to type %qT",
5613 arg
, from_type
, to_type
);
5618 unify_no_common_base (bool explain_p
, enum template_base_result r
,
5619 tree parm
, tree arg
)
5624 case tbr_ambiguous_baseclass
:
5625 inform (input_location
, " %qT is an ambiguous base class of %qT",
5629 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
5636 unify_inconsistent_template_template_parameters (bool explain_p
)
5639 inform (input_location
,
5640 " template parameters of a template template argument are "
5641 "inconsistent with other deduced template arguments");
5646 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
5649 inform (input_location
,
5650 " can't deduce a template for %qT from non-template type %qT",
5656 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
5659 inform (input_location
,
5660 " template argument %qE does not match %qD", arg
, parm
);
5665 unify_overload_resolution_failure (bool explain_p
, tree arg
)
5668 inform (input_location
,
5669 " could not resolve address from overloaded function %qE",
5674 /* Attempt to convert the non-type template parameter EXPR to the
5675 indicated TYPE. If the conversion is successful, return the
5676 converted value. If the conversion is unsuccessful, return
5677 NULL_TREE if we issued an error message, or error_mark_node if we
5678 did not. We issue error messages for out-and-out bad template
5679 parameters, but not simply because the conversion failed, since we
5680 might be just trying to do argument deduction. Both TYPE and EXPR
5681 must be non-dependent.
5683 The conversion follows the special rules described in
5684 [temp.arg.nontype], and it is much more strict than an implicit
5687 This function is called twice for each template argument (see
5688 lookup_template_class for a more accurate description of this
5689 problem). This means that we need to handle expressions which
5690 are not valid in a C++ source, but can be created from the
5691 first call (for instance, casts to perform conversions). These
5692 hacks can go away after we fix the double coercion problem. */
5695 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
5699 /* Detect immediately string literals as invalid non-type argument.
5700 This special-case is not needed for correctness (we would easily
5701 catch this later), but only to provide better diagnostic for this
5702 common user mistake. As suggested by DR 100, we do not mention
5703 linkage issues in the diagnostic as this is not the point. */
5704 /* FIXME we're making this OK. */
5705 if (TREE_CODE (expr
) == STRING_CST
)
5707 if (complain
& tf_error
)
5708 error ("%qE is not a valid template argument for type %qT "
5709 "because string literals can never be used in this context",
5714 /* Add the ADDR_EXPR now for the benefit of
5715 value_dependent_expression_p. */
5716 if (TYPE_PTROBV_P (type
)
5717 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
5719 expr
= decay_conversion (expr
, complain
);
5720 if (expr
== error_mark_node
)
5721 return error_mark_node
;
5724 /* If we are in a template, EXPR may be non-dependent, but still
5725 have a syntactic, rather than semantic, form. For example, EXPR
5726 might be a SCOPE_REF, rather than the VAR_DECL to which the
5727 SCOPE_REF refers. Preserving the qualifying scope is necessary
5728 so that access checking can be performed when the template is
5729 instantiated -- but here we need the resolved form so that we can
5730 convert the argument. */
5731 if (TYPE_REF_OBJ_P (type
)
5732 && has_value_dependent_address (expr
))
5733 /* If we want the address and it's value-dependent, don't fold. */;
5734 else if (!type_unknown_p (expr
))
5735 expr
= fold_non_dependent_expr_sfinae (expr
, complain
);
5736 if (error_operand_p (expr
))
5737 return error_mark_node
;
5738 expr_type
= TREE_TYPE (expr
);
5739 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5740 expr
= mark_lvalue_use (expr
);
5742 expr
= mark_rvalue_use (expr
);
5744 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5745 to a non-type argument of "nullptr". */
5746 if (expr
== nullptr_node
&& TYPE_PTR_OR_PTRMEM_P (type
))
5747 expr
= convert (type
, expr
);
5749 /* In C++11, integral or enumeration non-type template arguments can be
5750 arbitrary constant expressions. Pointer and pointer to
5751 member arguments can be general constant expressions that evaluate
5752 to a null value, but otherwise still need to be of a specific form. */
5753 if (cxx_dialect
>= cxx11
)
5755 if (TREE_CODE (expr
) == PTRMEM_CST
)
5756 /* A PTRMEM_CST is already constant, and a valid template
5757 argument for a parameter of pointer to member type, we just want
5758 to leave it in that form rather than lower it to a
5760 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5761 expr
= maybe_constant_value (expr
);
5762 else if (TYPE_PTR_OR_PTRMEM_P (type
))
5764 tree folded
= maybe_constant_value (expr
);
5765 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
5766 : null_member_pointer_value_p (folded
))
5771 /* HACK: Due to double coercion, we can get a
5772 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5773 which is the tree that we built on the first call (see
5774 below when coercing to reference to object or to reference to
5775 function). We just strip everything and get to the arg.
5776 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5778 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
5780 tree probe_type
, probe
= expr
;
5781 if (REFERENCE_REF_P (probe
))
5782 probe
= TREE_OPERAND (probe
, 0);
5783 probe_type
= TREE_TYPE (probe
);
5784 if (TREE_CODE (probe
) == NOP_EXPR
)
5786 /* ??? Maybe we could use convert_from_reference here, but we
5787 would need to relax its constraints because the NOP_EXPR
5788 could actually change the type to something more cv-qualified,
5789 and this is not folded by convert_from_reference. */
5790 tree addr
= TREE_OPERAND (probe
, 0);
5791 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
5792 && TREE_CODE (addr
) == ADDR_EXPR
5793 && TYPE_PTR_P (TREE_TYPE (addr
))
5794 && (same_type_ignoring_top_level_qualifiers_p
5795 (TREE_TYPE (probe_type
),
5796 TREE_TYPE (TREE_TYPE (addr
)))))
5798 expr
= TREE_OPERAND (addr
, 0);
5799 expr_type
= TREE_TYPE (probe_type
);
5804 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5805 parameter is a pointer to object, through decay and
5806 qualification conversion. Let's strip everything. */
5807 else if (TREE_CODE (expr
) == NOP_EXPR
&& TYPE_PTROBV_P (type
))
5811 if (TREE_CODE (probe
) == ADDR_EXPR
5812 && TYPE_PTR_P (TREE_TYPE (probe
)))
5814 /* Skip the ADDR_EXPR only if it is part of the decay for
5815 an array. Otherwise, it is part of the original argument
5816 in the source code. */
5817 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe
, 0))) == ARRAY_TYPE
)
5818 probe
= TREE_OPERAND (probe
, 0);
5820 expr_type
= TREE_TYPE (expr
);
5824 /* [temp.arg.nontype]/5, bullet 1
5826 For a non-type template-parameter of integral or enumeration type,
5827 integral promotions (_conv.prom_) and integral conversions
5828 (_conv.integral_) are applied. */
5829 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
5831 tree t
= build_integral_nontype_arg_conv (type
, expr
, complain
);
5832 t
= maybe_constant_value (t
);
5833 if (t
!= error_mark_node
)
5836 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
5837 return error_mark_node
;
5839 /* Notice that there are constant expressions like '4 % 0' which
5840 do not fold into integer constants. */
5841 if (TREE_CODE (expr
) != INTEGER_CST
)
5843 if (complain
& tf_error
)
5845 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
5846 if (processing_template_decl
5847 && !require_potential_constant_expression (expr
))
5849 expr
= cxx_constant_value (expr
);
5850 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
5851 inform (EXPR_LOC_OR_LOC (expr
, input_location
),
5852 "in template argument for type %qT ", type
);
5853 if (expr
== error_mark_node
)
5855 /* else cxx_constant_value complained but gave us
5856 a real constant, so go ahead. */
5857 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
5863 /* Avoid typedef problems. */
5864 if (TREE_TYPE (expr
) != type
)
5865 expr
= fold_convert (type
, expr
);
5867 /* [temp.arg.nontype]/5, bullet 2
5869 For a non-type template-parameter of type pointer to object,
5870 qualification conversions (_conv.qual_) and the array-to-pointer
5871 conversion (_conv.array_) are applied. */
5872 else if (TYPE_PTROBV_P (type
))
5874 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5876 A template-argument for a non-type, non-template template-parameter
5877 shall be one of: [...]
5879 -- the name of a non-type template-parameter;
5880 -- the address of an object or function with external linkage, [...]
5881 expressed as "& id-expression" where the & is optional if the name
5882 refers to a function or array, or if the corresponding
5883 template-parameter is a reference.
5885 Here, we do not care about functions, as they are invalid anyway
5886 for a parameter of type pointer-to-object. */
5888 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
5889 /* Non-type template parameters are OK. */
5891 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
5892 /* Null pointer values are OK in C++11. */;
5893 else if (TREE_CODE (expr
) != ADDR_EXPR
5894 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
5898 if (complain
& tf_error
)
5899 error ("%qD is not a valid template argument "
5900 "because %qD is a variable, not the address of "
5901 "a variable", expr
, expr
);
5904 if (POINTER_TYPE_P (expr_type
))
5906 if (complain
& tf_error
)
5907 error ("%qE is not a valid template argument for %qT "
5908 "because it is not the address of a variable",
5912 /* Other values, like integer constants, might be valid
5913 non-type arguments of some other type. */
5914 return error_mark_node
;
5920 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
5921 ? TREE_OPERAND (expr
, 0) : expr
);
5924 if (complain
& tf_error
)
5925 error ("%qE is not a valid template argument of type %qT "
5926 "because %qE is not a variable", expr
, type
, decl
);
5929 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
5931 if (complain
& tf_error
)
5932 error ("%qE is not a valid template argument of type %qT "
5933 "because %qD does not have external linkage",
5937 else if (cxx_dialect
>= cxx11
&& decl_linkage (decl
) == lk_none
)
5939 if (complain
& tf_error
)
5940 error ("%qE is not a valid template argument of type %qT "
5941 "because %qD has no linkage", expr
, type
, decl
);
5946 expr
= decay_conversion (expr
, complain
);
5947 if (expr
== error_mark_node
)
5948 return error_mark_node
;
5950 expr
= perform_qualification_conversions (type
, expr
);
5951 if (expr
== error_mark_node
)
5952 return error_mark_node
;
5954 /* [temp.arg.nontype]/5, bullet 3
5956 For a non-type template-parameter of type reference to object, no
5957 conversions apply. The type referred to by the reference may be more
5958 cv-qualified than the (otherwise identical) type of the
5959 template-argument. The template-parameter is bound directly to the
5960 template-argument, which must be an lvalue. */
5961 else if (TYPE_REF_OBJ_P (type
))
5963 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
5965 return error_mark_node
;
5967 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
5969 if (complain
& tf_error
)
5970 error ("%qE is not a valid template argument for type %qT "
5971 "because of conflicts in cv-qualification", expr
, type
);
5975 if (!real_lvalue_p (expr
))
5977 if (complain
& tf_error
)
5978 error ("%qE is not a valid template argument for type %qT "
5979 "because it is not an lvalue", expr
, type
);
5983 /* [temp.arg.nontype]/1
5985 A template-argument for a non-type, non-template template-parameter
5986 shall be one of: [...]
5988 -- the address of an object or function with external linkage. */
5989 if (INDIRECT_REF_P (expr
)
5990 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
5992 expr
= TREE_OPERAND (expr
, 0);
5995 if (complain
& tf_error
)
5996 error ("%q#D is not a valid template argument for type %qT "
5997 "because a reference variable does not have a constant "
5998 "address", expr
, type
);
6005 if (complain
& tf_error
)
6006 error ("%qE is not a valid template argument for type %qT "
6007 "because it is not an object with external linkage",
6012 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
6014 if (complain
& tf_error
)
6015 error ("%qE is not a valid template argument for type %qT "
6016 "because object %qD has not external linkage",
6021 expr
= build_nop (type
, build_address (expr
));
6023 /* [temp.arg.nontype]/5, bullet 4
6025 For a non-type template-parameter of type pointer to function, only
6026 the function-to-pointer conversion (_conv.func_) is applied. If the
6027 template-argument represents a set of overloaded functions (or a
6028 pointer to such), the matching function is selected from the set
6030 else if (TYPE_PTRFN_P (type
))
6032 /* If the argument is a template-id, we might not have enough
6033 context information to decay the pointer. */
6034 if (!type_unknown_p (expr_type
))
6036 expr
= decay_conversion (expr
, complain
);
6037 if (expr
== error_mark_node
)
6038 return error_mark_node
;
6041 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6042 /* Null pointer values are OK in C++11. */
6043 return perform_qualification_conversions (type
, expr
);
6045 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6046 if (!expr
|| expr
== error_mark_node
)
6049 /* [temp.arg.nontype]/5, bullet 5
6051 For a non-type template-parameter of type reference to function, no
6052 conversions apply. If the template-argument represents a set of
6053 overloaded functions, the matching function is selected from the set
6055 else if (TYPE_REFFN_P (type
))
6057 if (TREE_CODE (expr
) == ADDR_EXPR
)
6059 if (complain
& tf_error
)
6061 error ("%qE is not a valid template argument for type %qT "
6062 "because it is a pointer", expr
, type
);
6063 inform (input_location
, "try using %qE instead",
6064 TREE_OPERAND (expr
, 0));
6069 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6070 if (!expr
|| expr
== error_mark_node
)
6073 expr
= build_nop (type
, build_address (expr
));
6075 /* [temp.arg.nontype]/5, bullet 6
6077 For a non-type template-parameter of type pointer to member function,
6078 no conversions apply. If the template-argument represents a set of
6079 overloaded member functions, the matching member function is selected
6080 from the set (_over.over_). */
6081 else if (TYPE_PTRMEMFUNC_P (type
))
6083 expr
= instantiate_type (type
, expr
, tf_none
);
6084 if (expr
== error_mark_node
)
6085 return error_mark_node
;
6087 /* [temp.arg.nontype] bullet 1 says the pointer to member
6088 expression must be a pointer-to-member constant. */
6089 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6090 return error_mark_node
;
6092 /* There is no way to disable standard conversions in
6093 resolve_address_of_overloaded_function (called by
6094 instantiate_type). It is possible that the call succeeded by
6095 converting &B::I to &D::I (where B is a base of D), so we need
6096 to reject this conversion here.
6098 Actually, even if there was a way to disable standard conversions,
6099 it would still be better to reject them here so that we can
6100 provide a superior diagnostic. */
6101 if (!same_type_p (TREE_TYPE (expr
), type
))
6103 if (complain
& tf_error
)
6105 error ("%qE is not a valid template argument for type %qT "
6106 "because it is of type %qT", expr
, type
,
6108 /* If we are just one standard conversion off, explain. */
6109 if (can_convert_standard (type
, TREE_TYPE (expr
), complain
))
6110 inform (input_location
,
6111 "standard conversions are not allowed in this context");
6116 /* [temp.arg.nontype]/5, bullet 7
6118 For a non-type template-parameter of type pointer to data member,
6119 qualification conversions (_conv.qual_) are applied. */
6120 else if (TYPE_PTRDATAMEM_P (type
))
6122 /* [temp.arg.nontype] bullet 1 says the pointer to member
6123 expression must be a pointer-to-member constant. */
6124 if (!check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6125 return error_mark_node
;
6127 expr
= perform_qualification_conversions (type
, expr
);
6128 if (expr
== error_mark_node
)
6131 else if (NULLPTR_TYPE_P (type
))
6133 if (expr
!= nullptr_node
)
6135 if (complain
& tf_error
)
6136 error ("%qE is not a valid template argument for type %qT "
6137 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6142 /* A template non-type parameter must be one of the above. */
6146 /* Sanity check: did we actually convert the argument to the
6148 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6149 (type
, TREE_TYPE (expr
)));
6153 /* Subroutine of coerce_template_template_parms, which returns 1 if
6154 PARM_PARM and ARG_PARM match using the rule for the template
6155 parameters of template template parameters. Both PARM and ARG are
6156 template parameters; the rest of the arguments are the same as for
6157 coerce_template_template_parms.
6160 coerce_template_template_parm (tree parm
,
6162 tsubst_flags_t complain
,
6166 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6167 || parm
== NULL_TREE
|| error_operand_p (parm
))
6170 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6173 switch (TREE_CODE (parm
))
6176 /* We encounter instantiations of templates like
6177 template <template <template <class> class> class TT>
6180 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6181 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6183 if (!coerce_template_template_parms
6184 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6190 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6191 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6192 /* Argument is a parameter pack but parameter is not. */
6197 /* The tsubst call is used to handle cases such as
6199 template <int> class C {};
6200 template <class T, template <T> class TT> class D {};
6203 i.e. the parameter list of TT depends on earlier parameters. */
6204 if (!uses_template_parms (TREE_TYPE (arg
))
6206 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
6210 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6211 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6212 /* Argument is a parameter pack but parameter is not. */
6225 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6226 template template parameters. Both PARM_PARMS and ARG_PARMS are
6227 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6230 Consider the example:
6231 template <class T> class A;
6232 template<template <class U> class TT> class B;
6234 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6235 the parameters to A, and OUTER_ARGS contains A. */
6238 coerce_template_template_parms (tree parm_parms
,
6240 tsubst_flags_t complain
,
6244 int nparms
, nargs
, i
;
6248 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
6249 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
6251 nparms
= TREE_VEC_LENGTH (parm_parms
);
6252 nargs
= TREE_VEC_LENGTH (arg_parms
);
6254 /* Determine whether we have a parameter pack at the end of the
6255 template template parameter's template parameter list. */
6256 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
6258 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
6260 if (error_operand_p (parm
))
6263 switch (TREE_CODE (parm
))
6267 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6272 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6282 && !(variadic_p
&& nargs
>= nparms
- 1))
6285 /* Check all of the template parameters except the parameter pack at
6286 the end (if any). */
6287 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
6289 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
6290 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6293 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6294 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6296 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6304 /* Check each of the template parameters in the template
6305 argument against the template parameter pack at the end of
6306 the template template parameter. */
6307 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
6310 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
6312 for (; i
< nargs
; ++i
)
6314 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
6317 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
6319 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
6328 /* Verifies that the deduced template arguments (in TARGS) for the
6329 template template parameters (in TPARMS) represent valid bindings,
6330 by comparing the template parameter list of each template argument
6331 to the template parameter list of its corresponding template
6332 template parameter, in accordance with DR150. This
6333 routine can only be called after all template arguments have been
6334 deduced. It will return TRUE if all of the template template
6335 parameter bindings are okay, FALSE otherwise. */
6337 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
6339 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
6342 /* We're dealing with template parms in this process. */
6343 ++processing_template_decl
;
6345 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
6347 for (i
= 0; i
< ntparms
; ++i
)
6349 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
6350 tree targ
= TREE_VEC_ELT (targs
, i
);
6352 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
6354 tree packed_args
= NULL_TREE
;
6357 if (ARGUMENT_PACK_P (targ
))
6359 /* Look inside the argument pack. */
6360 packed_args
= ARGUMENT_PACK_ARGS (targ
);
6361 len
= TREE_VEC_LENGTH (packed_args
);
6364 for (idx
= 0; idx
< len
; ++idx
)
6366 tree targ_parms
= NULL_TREE
;
6369 /* Extract the next argument from the argument
6371 targ
= TREE_VEC_ELT (packed_args
, idx
);
6373 if (PACK_EXPANSION_P (targ
))
6374 /* Look at the pattern of the pack expansion. */
6375 targ
= PACK_EXPANSION_PATTERN (targ
);
6377 /* Extract the template parameters from the template
6379 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
6380 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
6381 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
6382 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
6384 /* Verify that we can coerce the template template
6385 parameters from the template argument to the template
6386 parameter. This requires an exact match. */
6388 && !coerce_template_template_parms
6389 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
6404 --processing_template_decl
;
6408 /* Since type attributes aren't mangled, we need to strip them from
6409 template type arguments. */
6412 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
6415 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
6417 mv
= TYPE_MAIN_VARIANT (arg
);
6418 arg
= strip_typedefs (arg
);
6419 if (TYPE_ALIGN (arg
) != TYPE_ALIGN (mv
)
6420 || TYPE_ATTRIBUTES (arg
) != TYPE_ATTRIBUTES (mv
))
6422 if (complain
& tf_warning
)
6423 warning (0, "ignoring attributes on template argument %qT", arg
);
6424 arg
= build_aligned_type (arg
, TYPE_ALIGN (mv
));
6425 arg
= cp_build_type_attribute_variant (arg
, TYPE_ATTRIBUTES (mv
));
6430 /* Convert the indicated template ARG as necessary to match the
6431 indicated template PARM. Returns the converted ARG, or
6432 error_mark_node if the conversion was unsuccessful. Error and
6433 warning messages are issued under control of COMPLAIN. This
6434 conversion is for the Ith parameter in the parameter list. ARGS is
6435 the full set of template arguments deduced so far. */
6438 convert_template_argument (tree parm
,
6441 tsubst_flags_t complain
,
6447 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
6449 if (TREE_CODE (arg
) == TREE_LIST
6450 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
6452 /* The template argument was the name of some
6453 member function. That's usually
6454 invalid, but static members are OK. In any
6455 case, grab the underlying fields/functions
6456 and issue an error later if required. */
6457 orig_arg
= TREE_VALUE (arg
);
6458 TREE_TYPE (arg
) = unknown_type_node
;
6463 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
6464 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
6465 || requires_tmpl_type
);
6467 /* When determining whether an argument pack expansion is a template,
6468 look at the pattern. */
6469 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
6470 arg
= PACK_EXPANSION_PATTERN (arg
);
6472 /* Deal with an injected-class-name used as a template template arg. */
6473 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
6475 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
6476 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6478 if (cxx_dialect
>= cxx11
)
6479 /* OK under DR 1004. */;
6480 else if (complain
& tf_warning_or_error
)
6481 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
6482 " used as template template argument", TYPE_NAME (arg
));
6483 else if (flag_pedantic_errors
)
6491 ((TREE_CODE (arg
) == TEMPLATE_DECL
6492 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
6493 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
6494 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6495 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
6498 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
6499 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
6500 arg
= TYPE_STUB_DECL (arg
);
6502 is_type
= TYPE_P (arg
) || is_tmpl_type
;
6504 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
6505 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
6507 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
6509 if (complain
& tf_error
)
6510 error ("invalid use of destructor %qE as a type", orig_arg
);
6511 return error_mark_node
;
6514 permerror (input_location
,
6515 "to refer to a type member of a template parameter, "
6516 "use %<typename %E%>", orig_arg
);
6518 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
6519 TREE_OPERAND (arg
, 1),
6525 if (is_type
!= requires_type
)
6529 if (complain
& tf_error
)
6531 error ("type/value mismatch at argument %d in template "
6532 "parameter list for %qD",
6535 inform (input_location
,
6536 " expected a constant of type %qT, got %qT",
6538 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
6539 else if (requires_tmpl_type
)
6540 inform (input_location
,
6541 " expected a class template, got %qE", orig_arg
);
6543 inform (input_location
,
6544 " expected a type, got %qE", orig_arg
);
6547 return error_mark_node
;
6549 if (is_tmpl_type
^ requires_tmpl_type
)
6551 if (in_decl
&& (complain
& tf_error
))
6553 error ("type/value mismatch at argument %d in template "
6554 "parameter list for %qD",
6557 inform (input_location
,
6558 " expected a type, got %qT", DECL_NAME (arg
));
6560 inform (input_location
,
6561 " expected a class template, got %qT", orig_arg
);
6563 return error_mark_node
;
6568 if (requires_tmpl_type
)
6570 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6572 else if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
6573 /* The number of argument required is not known yet.
6574 Just accept it for now. */
6575 val
= TREE_TYPE (arg
);
6578 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6581 /* Strip alias templates that are equivalent to another
6583 arg
= get_underlying_template (arg
);
6584 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6586 if (coerce_template_template_parms (parmparm
, argparm
,
6592 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6594 if (val
!= error_mark_node
)
6596 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
6597 val
= TREE_TYPE (val
);
6598 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
6599 val
= make_pack_expansion (val
);
6604 if (in_decl
&& (complain
& tf_error
))
6606 error ("type/value mismatch at argument %d in "
6607 "template parameter list for %qD",
6609 inform (input_location
,
6610 " expected a template of type %qD, got %qT",
6614 val
= error_mark_node
;
6620 /* We only form one instance of each template specialization.
6621 Therefore, if we use a non-canonical variant (i.e., a
6622 typedef), any future messages referring to the type will use
6623 the typedef, which is confusing if those future uses do not
6624 themselves also use the typedef. */
6626 val
= canonicalize_type_argument (val
, complain
);
6630 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
6632 if (invalid_nontype_parm_type_p (t
, complain
))
6633 return error_mark_node
;
6635 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
6637 if (same_type_p (t
, TREE_TYPE (orig_arg
)))
6641 /* Not sure if this is reachable, but it doesn't hurt
6643 error ("type mismatch in nontype parameter pack");
6644 val
= error_mark_node
;
6647 else if (!dependent_template_arg_p (orig_arg
)
6648 && !uses_template_parms (t
))
6649 /* We used to call digest_init here. However, digest_init
6650 will report errors, which we don't want when complain
6651 is zero. More importantly, digest_init will try too
6652 hard to convert things: for example, `0' should not be
6653 converted to pointer type at this point according to
6654 the standard. Accepting this is not merely an
6655 extension, since deciding whether or not these
6656 conversions can occur is part of determining which
6657 function template to call, or whether a given explicit
6658 argument specification is valid. */
6659 val
= convert_nontype_argument (t
, orig_arg
, complain
);
6661 val
= strip_typedefs_expr (orig_arg
);
6663 if (val
== NULL_TREE
)
6664 val
= error_mark_node
;
6665 else if (val
== error_mark_node
&& (complain
& tf_error
))
6666 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
6668 if (TREE_CODE (val
) == SCOPE_REF
)
6670 /* Strip typedefs from the SCOPE_REF. */
6671 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
6672 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
6674 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
6675 QUALIFIED_NAME_IS_TEMPLATE (val
));
6682 /* Coerces the remaining template arguments in INNER_ARGS (from
6683 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6684 Returns the coerced argument pack. PARM_IDX is the position of this
6685 parameter in the template parameter list. ARGS is the original
6686 template argument list. */
6688 coerce_template_parameter_pack (tree parms
,
6696 tsubst_flags_t complain
)
6698 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6699 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6702 tree packed_parms
= NULL_TREE
;
6704 if (arg_idx
> nargs
)
6707 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
6709 /* When the template parameter is a non-type template parameter pack
6710 or template template parameter pack whose type or template
6711 parameters use parameter packs, we know exactly how many arguments
6712 we are looking for. Build a vector of the instantiated decls for
6713 these template parameters in PACKED_PARMS. */
6714 /* We can't use make_pack_expansion here because it would interpret a
6715 _DECL as a use rather than a declaration. */
6716 tree decl
= TREE_VALUE (parm
);
6717 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
6718 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
6719 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
6720 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
6722 TREE_VEC_LENGTH (args
)--;
6723 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
6724 TREE_VEC_LENGTH (args
)++;
6726 if (packed_parms
== error_mark_node
)
6727 return error_mark_node
;
6729 /* If we're doing a partial instantiation of a member template,
6730 verify that all of the types used for the non-type
6731 template parameter pack are, in fact, valid for non-type
6732 template parameters. */
6734 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
6736 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
6737 for (j
= 0; j
< len
; ++j
)
6739 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
6740 if (invalid_nontype_parm_type_p (t
, complain
))
6741 return error_mark_node
;
6745 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
6748 packed_args
= make_tree_vec (nargs
- arg_idx
);
6750 /* Convert the remaining arguments, which will be a part of the
6751 parameter pack "parm". */
6752 for (; arg_idx
< nargs
; ++arg_idx
)
6754 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6755 tree actual_parm
= TREE_VALUE (parm
);
6756 int pack_idx
= arg_idx
- parm_idx
;
6760 /* Once we've packed as many args as we have types, stop. */
6761 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
6763 else if (PACK_EXPANSION_P (arg
))
6764 /* We don't know how many args we have yet, just
6765 use the unconverted ones for now. */
6768 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
6771 if (arg
== error_mark_node
)
6773 if (complain
& tf_error
)
6774 error ("template argument %d is invalid", arg_idx
+ 1);
6777 arg
= convert_template_argument (actual_parm
,
6778 arg
, new_args
, complain
, parm_idx
,
6780 if (arg
== error_mark_node
)
6782 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
6785 if (arg_idx
- parm_idx
< TREE_VEC_LENGTH (packed_args
)
6786 && TREE_VEC_LENGTH (packed_args
) > 0)
6788 if (complain
& tf_error
)
6789 error ("wrong number of template arguments (%d, should be %d)",
6790 arg_idx
- parm_idx
, TREE_VEC_LENGTH (packed_args
));
6791 return error_mark_node
;
6794 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
6795 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
6796 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
6799 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
6800 TREE_TYPE (argument_pack
)
6801 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
6802 TREE_CONSTANT (argument_pack
) = 1;
6805 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
6806 #ifdef ENABLE_CHECKING
6807 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
6808 TREE_VEC_LENGTH (packed_args
));
6810 return argument_pack
;
6813 /* Returns the number of pack expansions in the template argument vector
6817 pack_expansion_args_count (tree args
)
6822 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
6824 tree elt
= TREE_VEC_ELT (args
, i
);
6825 if (elt
&& PACK_EXPANSION_P (elt
))
6831 /* Convert all template arguments to their appropriate types, and
6832 return a vector containing the innermost resulting template
6833 arguments. If any error occurs, return error_mark_node. Error and
6834 warning messages are issued under control of COMPLAIN.
6836 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6837 for arguments not specified in ARGS. Otherwise, if
6838 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6839 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6840 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6844 coerce_template_parms (tree parms
,
6847 tsubst_flags_t complain
,
6848 bool require_all_args
,
6849 bool use_default_args
)
6851 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
6852 tree orig_inner_args
;
6855 tree new_inner_args
;
6856 int saved_unevaluated_operand
;
6857 int saved_inhibit_evaluation_warnings
;
6859 /* When used as a boolean value, indicates whether this is a
6860 variadic template parameter list. Since it's an int, we can also
6861 subtract it from nparms to get the number of non-variadic
6864 int variadic_args_p
= 0;
6865 int post_variadic_parms
= 0;
6867 /* Likewise for parameters with default arguments. */
6870 if (args
== error_mark_node
)
6871 return error_mark_node
;
6873 nparms
= TREE_VEC_LENGTH (parms
);
6875 /* Determine if there are any parameter packs or default arguments. */
6876 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
6878 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
6880 ++post_variadic_parms
;
6881 if (template_parameter_pack_p (TREE_VALUE (parm
)))
6883 if (TREE_PURPOSE (parm
))
6887 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
6888 /* If there are no parameters that follow a parameter pack, we need to
6889 expand any argument packs so that we can deduce a parameter pack from
6890 some non-packed args followed by an argument pack, as in variadic85.C.
6891 If there are such parameters, we need to leave argument packs intact
6892 so the arguments are assigned properly. This can happen when dealing
6893 with a nested class inside a partial specialization of a class
6894 template, as in variadic92.C, or when deducing a template parameter pack
6895 from a sub-declarator, as in variadic114.C. */
6896 if (!post_variadic_parms
)
6897 inner_args
= expand_template_argument_pack (inner_args
);
6899 /* Count any pack expansion args. */
6900 variadic_args_p
= pack_expansion_args_count (inner_args
);
6902 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
6903 if ((nargs
> nparms
&& !variadic_p
)
6904 || (nargs
< nparms
- variadic_p
6907 && (!use_default_args
6908 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
6909 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
6911 if (complain
& tf_error
)
6913 if (variadic_p
|| default_p
)
6915 nparms
-= variadic_p
+ default_p
;
6916 error ("wrong number of template arguments "
6917 "(%d, should be at least %d)", nargs
, nparms
);
6920 error ("wrong number of template arguments "
6921 "(%d, should be %d)", nargs
, nparms
);
6924 inform (input_location
, "provided for %q+D", in_decl
);
6927 return error_mark_node
;
6929 /* We can't pass a pack expansion to a non-pack parameter of an alias
6930 template (DR 1430). */
6931 else if (in_decl
&& DECL_ALIAS_TEMPLATE_P (in_decl
)
6933 && nargs
- variadic_args_p
< nparms
- variadic_p
)
6935 if (complain
& tf_error
)
6937 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
6939 tree arg
= TREE_VEC_ELT (inner_args
, i
);
6940 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
6942 if (PACK_EXPANSION_P (arg
)
6943 && !template_parameter_pack_p (parm
))
6945 error ("pack expansion argument for non-pack parameter "
6946 "%qD of alias template %qD", parm
, in_decl
);
6947 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
6954 return error_mark_node
;
6957 /* We need to evaluate the template arguments, even though this
6958 template-id may be nested within a "sizeof". */
6959 saved_unevaluated_operand
= cp_unevaluated_operand
;
6960 cp_unevaluated_operand
= 0;
6961 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
6962 c_inhibit_evaluation_warnings
= 0;
6963 new_inner_args
= make_tree_vec (nparms
);
6964 new_args
= add_outermost_template_args (args
, new_inner_args
);
6965 int pack_adjust
= 0;
6966 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
6971 /* Get the Ith template parameter. */
6972 parm
= TREE_VEC_ELT (parms
, parm_idx
);
6974 if (parm
== error_mark_node
)
6976 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
6980 /* Calculate the next argument. */
6981 if (arg_idx
< nargs
)
6982 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
6986 if (template_parameter_pack_p (TREE_VALUE (parm
))
6987 && !(arg
&& ARGUMENT_PACK_P (arg
)))
6989 /* Some arguments will be placed in the
6990 template parameter pack PARM. */
6991 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
6992 inner_args
, arg_idx
,
6996 if (arg
== NULL_TREE
)
6998 /* We don't know how many args we have yet, just use the
6999 unconverted (and still packed) ones for now. */
7000 new_inner_args
= orig_inner_args
;
7005 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
7007 /* Store this argument. */
7008 if (arg
== error_mark_node
)
7011 /* We are done with all of the arguments. */
7016 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
7017 arg_idx
+= pack_adjust
;
7024 if (PACK_EXPANSION_P (arg
))
7026 /* "If every valid specialization of a variadic template
7027 requires an empty template parameter pack, the template is
7028 ill-formed, no diagnostic required." So check that the
7029 pattern works with this parameter. */
7030 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
7031 tree conv
= convert_template_argument (TREE_VALUE (parm
),
7035 if (conv
== error_mark_node
)
7037 inform (input_location
, "so any instantiation with a "
7038 "non-empty parameter pack would be ill-formed");
7041 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
7042 /* Recover from missing typename. */
7043 TREE_VEC_ELT (inner_args
, arg_idx
)
7044 = make_pack_expansion (conv
);
7046 /* We don't know how many args we have yet, just
7047 use the unconverted ones for now. */
7048 new_inner_args
= inner_args
;
7053 else if (require_all_args
)
7055 /* There must be a default arg in this case. */
7056 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
7058 /* The position of the first default template argument,
7059 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7061 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7062 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7063 arg_idx
- pack_adjust
);
7068 if (arg
== error_mark_node
)
7070 if (complain
& tf_error
)
7071 error ("template argument %d is invalid", arg_idx
+ 1);
7074 /* This only occurs if there was an error in the template
7075 parameter list itself (which we would already have
7076 reported) that we are trying to recover from, e.g., a class
7077 template with a parameter list such as
7078 template<typename..., typename>. */
7081 arg
= convert_template_argument (TREE_VALUE (parm
),
7082 arg
, new_args
, complain
,
7085 if (arg
== error_mark_node
)
7087 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
7089 cp_unevaluated_operand
= saved_unevaluated_operand
;
7090 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
7092 if (variadic_p
&& arg_idx
< nargs
)
7094 if (complain
& tf_error
)
7096 error ("wrong number of template arguments "
7097 "(%d, should be %d)", nargs
, arg_idx
);
7099 error ("provided for %q+D", in_decl
);
7101 return error_mark_node
;
7105 return error_mark_node
;
7107 #ifdef ENABLE_CHECKING
7108 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
7109 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
7110 TREE_VEC_LENGTH (new_inner_args
));
7113 return new_inner_args
;
7116 /* Like coerce_template_parms. If PARMS represents all template
7117 parameters levels, this function returns a vector of vectors
7118 representing all the resulting argument levels. Note that in this
7119 case, only the innermost arguments are coerced because the
7120 outermost ones are supposed to have been coerced already.
7122 Otherwise, if PARMS represents only (the innermost) vector of
7123 parameters, this function returns a vector containing just the
7124 innermost resulting arguments. */
7127 coerce_innermost_template_parms (tree parms
,
7130 tsubst_flags_t complain
,
7131 bool require_all_args
,
7132 bool use_default_args
)
7134 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
7135 int args_depth
= TMPL_ARGS_DEPTH (args
);
7138 if (parms_depth
> 1)
7140 coerced_args
= make_tree_vec (parms_depth
);
7144 for (level
= parms
, cur_depth
= parms_depth
;
7145 parms_depth
> 0 && level
!= NULL_TREE
;
7146 level
= TREE_CHAIN (level
), --cur_depth
)
7149 if (cur_depth
== args_depth
)
7150 l
= coerce_template_parms (TREE_VALUE (level
),
7151 args
, in_decl
, complain
,
7155 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
7157 if (l
== error_mark_node
)
7158 return error_mark_node
;
7160 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
7164 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
7165 args
, in_decl
, complain
,
7168 return coerced_args
;
7171 /* Returns 1 if template args OT and NT are equivalent. */
7174 template_args_equal (tree ot
, tree nt
)
7178 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
7181 if (TREE_CODE (nt
) == TREE_VEC
)
7182 /* For member templates */
7183 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
7184 else if (PACK_EXPANSION_P (ot
))
7185 return (PACK_EXPANSION_P (nt
)
7186 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
7187 PACK_EXPANSION_PATTERN (nt
))
7188 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
7189 PACK_EXPANSION_EXTRA_ARGS (nt
)));
7190 else if (ARGUMENT_PACK_P (ot
))
7195 if (!ARGUMENT_PACK_P (nt
))
7198 opack
= ARGUMENT_PACK_ARGS (ot
);
7199 npack
= ARGUMENT_PACK_ARGS (nt
);
7200 len
= TREE_VEC_LENGTH (opack
);
7201 if (TREE_VEC_LENGTH (npack
) != len
)
7203 for (i
= 0; i
< len
; ++i
)
7204 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
7205 TREE_VEC_ELT (npack
, i
)))
7209 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
7211 /* We get here probably because we are in the middle of substituting
7212 into the pattern of a pack expansion. In that case the
7213 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7214 interested in. So we want to use the initial pack argument for
7216 ot
= ARGUMENT_PACK_SELECT_FROM_PACK (ot
);
7217 if (nt
&& TREE_CODE (nt
) == ARGUMENT_PACK_SELECT
)
7218 nt
= ARGUMENT_PACK_SELECT_FROM_PACK (nt
);
7219 return template_args_equal (ot
, nt
);
7221 else if (TYPE_P (nt
))
7222 return TYPE_P (ot
) && same_type_p (ot
, nt
);
7223 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
7226 return cp_tree_equal (ot
, nt
);
7229 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7230 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7231 NEWARG_PTR with the offending arguments if they are non-NULL. */
7234 comp_template_args_with_info (tree oldargs
, tree newargs
,
7235 tree
*oldarg_ptr
, tree
*newarg_ptr
)
7239 if (oldargs
== newargs
)
7242 if (!oldargs
|| !newargs
)
7245 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
7248 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
7250 tree nt
= TREE_VEC_ELT (newargs
, i
);
7251 tree ot
= TREE_VEC_ELT (oldargs
, i
);
7253 if (! template_args_equal (ot
, nt
))
7255 if (oldarg_ptr
!= NULL
)
7257 if (newarg_ptr
!= NULL
)
7265 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7266 of template arguments. Returns 0 otherwise. */
7269 comp_template_args (tree oldargs
, tree newargs
)
7271 return comp_template_args_with_info (oldargs
, newargs
, NULL
, NULL
);
7275 add_pending_template (tree d
)
7277 tree ti
= (TYPE_P (d
)
7278 ? CLASSTYPE_TEMPLATE_INFO (d
)
7279 : DECL_TEMPLATE_INFO (d
));
7280 struct pending_template
*pt
;
7283 if (TI_PENDING_TEMPLATE_FLAG (ti
))
7286 /* We are called both from instantiate_decl, where we've already had a
7287 tinst_level pushed, and instantiate_template, where we haven't.
7289 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
7292 push_tinst_level (d
);
7294 pt
= ggc_alloc
<pending_template
> ();
7296 pt
->tinst
= current_tinst_level
;
7297 if (last_pending_template
)
7298 last_pending_template
->next
= pt
;
7300 pending_templates
= pt
;
7302 last_pending_template
= pt
;
7304 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
7311 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7312 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7313 documentation for TEMPLATE_ID_EXPR. */
7316 lookup_template_function (tree fns
, tree arglist
)
7320 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
7321 return error_mark_node
;
7323 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
7325 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
7327 error ("%q#D is not a function template", fns
);
7328 return error_mark_node
;
7331 if (BASELINK_P (fns
))
7333 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
7335 BASELINK_FUNCTIONS (fns
),
7340 type
= TREE_TYPE (fns
);
7341 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
7342 type
= unknown_type_node
;
7344 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
7347 /* Within the scope of a template class S<T>, the name S gets bound
7348 (in build_self_reference) to a TYPE_DECL for the class, not a
7349 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7350 or one of its enclosing classes, and that type is a template,
7351 return the associated TEMPLATE_DECL. Otherwise, the original
7354 Also handle the case when DECL is a TREE_LIST of ambiguous
7355 injected-class-names from different bases. */
7358 maybe_get_template_decl_from_type_decl (tree decl
)
7360 if (decl
== NULL_TREE
)
7363 /* DR 176: A lookup that finds an injected-class-name (10.2
7364 [class.member.lookup]) can result in an ambiguity in certain cases
7365 (for example, if it is found in more than one base class). If all of
7366 the injected-class-names that are found refer to specializations of
7367 the same class template, and if the name is followed by a
7368 template-argument-list, the reference refers to the class template
7369 itself and not a specialization thereof, and is not ambiguous. */
7370 if (TREE_CODE (decl
) == TREE_LIST
)
7372 tree t
, tmpl
= NULL_TREE
;
7373 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
7375 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
7378 else if (tmpl
!= elt
)
7381 if (tmpl
&& t
== NULL_TREE
)
7387 return (decl
!= NULL_TREE
7388 && DECL_SELF_REFERENCE_P (decl
)
7389 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
7390 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
7393 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7394 parameters, find the desired type.
7396 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7398 IN_DECL, if non-NULL, is the template declaration we are trying to
7401 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7402 the class we are looking up.
7404 Issue error and warning messages under control of COMPLAIN.
7406 If the template class is really a local class in a template
7407 function, then the FUNCTION_CONTEXT is the function in which it is
7410 ??? Note that this function is currently called *twice* for each
7411 template-id: the first time from the parser, while creating the
7412 incomplete type (finish_template_type), and the second type during the
7413 real instantiation (instantiate_template_class). This is surely something
7414 that we want to avoid. It also causes some problems with argument
7415 coercion (see convert_nontype_argument for more information on this). */
7418 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
7419 int entering_scope
, tsubst_flags_t complain
)
7421 tree templ
= NULL_TREE
, parmlist
;
7428 if (identifier_p (d1
))
7430 tree value
= innermost_non_namespace_value (d1
);
7431 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
7436 push_decl_namespace (context
);
7437 templ
= lookup_name (d1
);
7438 templ
= maybe_get_template_decl_from_type_decl (templ
);
7440 pop_decl_namespace ();
7443 context
= DECL_CONTEXT (templ
);
7445 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
7447 tree type
= TREE_TYPE (d1
);
7449 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7450 an implicit typename for the second A. Deal with it. */
7451 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
7452 type
= TREE_TYPE (type
);
7454 if (CLASSTYPE_TEMPLATE_INFO (type
))
7456 templ
= CLASSTYPE_TI_TEMPLATE (type
);
7457 d1
= DECL_NAME (templ
);
7460 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
7461 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
7463 templ
= TYPE_TI_TEMPLATE (d1
);
7464 d1
= DECL_NAME (templ
);
7466 else if (DECL_TYPE_TEMPLATE_P (d1
))
7469 d1
= DECL_NAME (templ
);
7470 context
= DECL_CONTEXT (templ
);
7472 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
7475 d1
= DECL_NAME (templ
);
7478 /* Issue an error message if we didn't find a template. */
7481 if (complain
& tf_error
)
7482 error ("%qT is not a template", d1
);
7483 return error_mark_node
;
7486 if (TREE_CODE (templ
) != TEMPLATE_DECL
7487 /* Make sure it's a user visible template, if it was named by
7489 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
7490 && !PRIMARY_TEMPLATE_P (templ
)))
7492 if (complain
& tf_error
)
7494 error ("non-template type %qT used as a template", d1
);
7496 error ("for template declaration %q+D", in_decl
);
7498 return error_mark_node
;
7501 complain
&= ~tf_user
;
7503 /* An alias that just changes the name of a template is equivalent to the
7504 other template, so if any of the arguments are pack expansions, strip
7505 the alias to avoid problems with a pack expansion passed to a non-pack
7506 alias template parameter (DR 1430). */
7507 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
7508 templ
= get_underlying_template (templ
);
7510 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
7512 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7513 template arguments */
7519 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7521 /* Consider an example where a template template parameter declared as
7523 template <class T, class U = std::allocator<T> > class TT
7525 The template parameter level of T and U are one level larger than
7526 of TT. To proper process the default argument of U, say when an
7527 instantiation `TT<int>' is seen, we need to build the full
7528 arguments containing {int} as the innermost level. Outer levels,
7529 available when not appearing as default template argument, can be
7530 obtained from the arguments of the enclosing template.
7532 Suppose that TT is later substituted with std::vector. The above
7533 instantiation is `TT<int, std::allocator<T> >' with TT at
7534 level 1, and T at level 2, while the template arguments at level 1
7535 becomes {std::vector} and the inner level 2 is {int}. */
7537 outer
= DECL_CONTEXT (templ
);
7539 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7540 else if (current_template_parms
)
7541 /* This is an argument of the current template, so we haven't set
7542 DECL_CONTEXT yet. */
7543 outer
= current_template_args ();
7546 arglist
= add_to_template_args (outer
, arglist
);
7548 arglist2
= coerce_template_parms (parmlist
, arglist
, templ
,
7550 /*require_all_args=*/true,
7551 /*use_default_args=*/true);
7552 if (arglist2
== error_mark_node
7553 || (!uses_template_parms (arglist2
)
7554 && check_instantiated_args (templ
, arglist2
, complain
)))
7555 return error_mark_node
;
7557 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
7562 tree template_type
= TREE_TYPE (templ
);
7565 tree found
= NULL_TREE
;
7568 int is_dependent_type
;
7569 int use_partial_inst_tmpl
= false;
7571 if (template_type
== error_mark_node
)
7572 /* An error occurred while building the template TEMPL, and a
7573 diagnostic has most certainly been emitted for that
7574 already. Let's propagate that error. */
7575 return error_mark_node
;
7577 gen_tmpl
= most_general_template (templ
);
7578 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7579 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
7580 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7582 if (arg_depth
== 1 && parm_depth
> 1)
7584 /* We've been given an incomplete set of template arguments.
7587 template <class T> struct S1 {
7588 template <class U> struct S2 {};
7589 template <class U> struct S2<U*> {};
7592 we will be called with an ARGLIST of `U*', but the
7593 TEMPLATE will be `template <class T> template
7594 <class U> struct S1<T>::S2'. We must fill in the missing
7597 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ
)),
7599 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
7602 /* Now we should have enough arguments. */
7603 gcc_assert (parm_depth
== arg_depth
);
7605 /* From here on, we're only interested in the most general
7608 /* Calculate the BOUND_ARGS. These will be the args that are
7609 actually tsubst'd into the definition to create the
7613 /* We have multiple levels of arguments to coerce, at once. */
7615 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
7617 tree bound_args
= make_tree_vec (parm_depth
);
7619 for (i
= saved_depth
,
7620 t
= DECL_TEMPLATE_PARMS (gen_tmpl
);
7621 i
> 0 && t
!= NULL_TREE
;
7622 --i
, t
= TREE_CHAIN (t
))
7625 if (i
== saved_depth
)
7626 a
= coerce_template_parms (TREE_VALUE (t
),
7629 /*require_all_args=*/true,
7630 /*use_default_args=*/true);
7632 /* Outer levels should have already been coerced. */
7633 a
= TMPL_ARGS_LEVEL (arglist
, i
);
7635 /* Don't process further if one of the levels fails. */
7636 if (a
== error_mark_node
)
7638 /* Restore the ARGLIST to its full size. */
7639 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7640 return error_mark_node
;
7643 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
7645 /* We temporarily reduce the length of the ARGLIST so
7646 that coerce_template_parms will see only the arguments
7647 corresponding to the template parameters it is
7649 TREE_VEC_LENGTH (arglist
)--;
7652 /* Restore the ARGLIST to its full size. */
7653 TREE_VEC_LENGTH (arglist
) = saved_depth
;
7655 arglist
= bound_args
;
7659 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
7660 INNERMOST_TEMPLATE_ARGS (arglist
),
7663 /*require_all_args=*/true,
7664 /*use_default_args=*/true);
7666 if (arglist
== error_mark_node
)
7667 /* We were unable to bind the arguments. */
7668 return error_mark_node
;
7670 /* In the scope of a template class, explicit references to the
7671 template class refer to the type of the template, not any
7672 instantiation of it. For example, in:
7674 template <class T> class C { void f(C<T>); }
7676 the `C<T>' is just the same as `C'. Outside of the
7677 class, however, such a reference is an instantiation. */
7679 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
7680 || currently_open_class (template_type
))
7681 /* comp_template_args is expensive, check it last. */
7682 && comp_template_args (TYPE_TI_ARGS (template_type
),
7684 return template_type
;
7686 /* If we already have this specialization, return it. */
7687 elt
.tmpl
= gen_tmpl
;
7689 hash
= hash_specialization (&elt
);
7690 entry
= (spec_entry
*) htab_find_with_hash (type_specializations
,
7696 is_dependent_type
= uses_template_parms (arglist
);
7698 /* If the deduced arguments are invalid, then the binding
7700 if (!is_dependent_type
7701 && check_instantiated_args (gen_tmpl
,
7702 INNERMOST_TEMPLATE_ARGS (arglist
),
7704 return error_mark_node
;
7706 if (!is_dependent_type
7707 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7708 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
7709 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
7711 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
7712 DECL_NAME (gen_tmpl
),
7713 /*tag_scope=*/ts_global
);
7717 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
7719 if (context
== error_mark_node
)
7720 return error_mark_node
;
7723 context
= global_namespace
;
7725 /* Create the type. */
7726 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7728 /* The user referred to a specialization of an alias
7729 template represented by GEN_TMPL.
7731 [temp.alias]/2 says:
7733 When a template-id refers to the specialization of an
7734 alias template, it is equivalent to the associated
7735 type obtained by substitution of its
7736 template-arguments for the template-parameters in the
7737 type-id of the alias template. */
7739 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
7740 /* Note that the call above (by indirectly calling
7741 register_specialization in tsubst_decl) registers the
7742 TYPE_DECL representing the specialization of the alias
7743 template. So next time someone substitutes ARGLIST for
7744 the template parms into the alias template (GEN_TMPL),
7745 she'll get that TYPE_DECL back. */
7747 if (t
== error_mark_node
)
7750 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
7752 if (!is_dependent_type
)
7754 set_current_access_from_decl (TYPE_NAME (template_type
));
7755 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
7756 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
7757 arglist
, complain
, in_decl
),
7758 SCOPED_ENUM_P (template_type
), NULL
);
7760 if (t
== error_mark_node
)
7765 /* We don't want to call start_enum for this type, since
7766 the values for the enumeration constants may involve
7767 template parameters. And, no one should be interested
7768 in the enumeration constants for such a type. */
7769 t
= cxx_make_type (ENUMERAL_TYPE
);
7770 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
7772 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
7773 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
7774 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
7776 else if (CLASS_TYPE_P (template_type
))
7778 t
= make_class_type (TREE_CODE (template_type
));
7779 CLASSTYPE_DECLARED_CLASS (t
)
7780 = CLASSTYPE_DECLARED_CLASS (template_type
);
7781 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
7782 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
7784 /* A local class. Make sure the decl gets registered properly. */
7785 if (context
== current_function_decl
)
7786 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
7788 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
7789 /* This instantiation is another name for the primary
7790 template type. Set the TYPE_CANONICAL field
7792 TYPE_CANONICAL (t
) = template_type
;
7793 else if (any_template_arguments_need_structural_equality_p (arglist
))
7794 /* Some of the template arguments require structural
7795 equality testing, so this template class requires
7796 structural equality testing. */
7797 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7802 /* If we called start_enum or pushtag above, this information
7803 will already be set up. */
7806 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
7808 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
7809 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
7810 DECL_SOURCE_LOCATION (type_decl
)
7811 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
7814 type_decl
= TYPE_NAME (t
);
7816 if (CLASS_TYPE_P (template_type
))
7818 TREE_PRIVATE (type_decl
)
7819 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
7820 TREE_PROTECTED (type_decl
)
7821 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
7822 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
7824 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
7825 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
7829 if (OVERLOAD_TYPE_P (t
)
7830 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7832 = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (template_type
)))
7833 TYPE_ATTRIBUTES (t
) = attributes
;
7835 /* Let's consider the explicit specialization of a member
7836 of a class template specialization that is implicitly instantiated,
7841 template<class U> struct M {}; //#0
7846 struct S<int>::M<char> //#1
7850 [temp.expl.spec]/4 says this is valid.
7852 In this case, when we write:
7855 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7858 When we encounter #1, we want to store the partial instantiation
7859 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7861 For all cases other than this "explicit specialization of member of a
7862 class template", we just want to store the most general template into
7863 the CLASSTYPE_TI_TEMPLATE of M.
7865 This case of "explicit specialization of member of a class template"
7867 1/ the enclosing class is an instantiation of, and therefore not
7868 the same as, the context of the most general template, and
7869 2/ we aren't looking at the partial instantiation itself, i.e.
7870 the innermost arguments are not the same as the innermost parms of
7871 the most general template.
7873 So it's only when 1/ and 2/ happens that we want to use the partial
7874 instantiation of the member template in lieu of its most general
7877 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
7878 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
7879 /* the enclosing class must be an instantiation... */
7880 && CLASS_TYPE_P (context
)
7881 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
7883 tree partial_inst_args
;
7884 TREE_VEC_LENGTH (arglist
)--;
7885 ++processing_template_decl
;
7887 tsubst (INNERMOST_TEMPLATE_ARGS
7888 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl
))),
7889 arglist
, complain
, NULL_TREE
);
7890 --processing_template_decl
;
7891 TREE_VEC_LENGTH (arglist
)++;
7892 use_partial_inst_tmpl
=
7893 /*...and we must not be looking at the partial instantiation
7895 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
7899 if (!use_partial_inst_tmpl
)
7900 /* This case is easy; there are no member templates involved. */
7904 /* This is a full instantiation of a member template. Find
7905 the partial instantiation of which this is an instance. */
7907 /* Temporarily reduce by one the number of levels in the ARGLIST
7908 so as to avoid comparing the last set of arguments. */
7909 TREE_VEC_LENGTH (arglist
)--;
7910 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
7911 TREE_VEC_LENGTH (arglist
)++;
7912 /* FOUND is either a proper class type, or an alias
7913 template specialization. In the later case, it's a
7914 TYPE_DECL, resulting from the substituting of arguments
7915 for parameters in the TYPE_DECL of the alias template
7916 done earlier. So be careful while getting the template
7918 found
= TREE_CODE (found
) == TYPE_DECL
7919 ? TYPE_TI_TEMPLATE (TREE_TYPE (found
))
7920 : CLASSTYPE_TI_TEMPLATE (found
);
7923 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
7926 slot
= htab_find_slot_with_hash (type_specializations
,
7927 &elt
, hash
, INSERT
);
7928 entry
= ggc_alloc
<spec_entry
> ();
7932 /* Note this use of the partial instantiation so we can check it
7933 later in maybe_process_partial_specialization. */
7934 DECL_TEMPLATE_INSTANTIATIONS (found
)
7935 = tree_cons (arglist
, t
,
7936 DECL_TEMPLATE_INSTANTIATIONS (found
));
7938 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
7939 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
7940 /* Now that the type has been registered on the instantiations
7941 list, we set up the enumerators. Because the enumeration
7942 constants may involve the enumeration type itself, we make
7943 sure to register the type first, and then create the
7944 constants. That way, doing tsubst_expr for the enumeration
7945 constants won't result in recursive calls here; we'll find
7946 the instantiation and exit above. */
7947 tsubst_enum (template_type
, t
, arglist
);
7949 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
7950 /* If the type makes use of template parameters, the
7951 code that generates debugging information will crash. */
7952 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
7954 /* Possibly limit visibility based on template args. */
7955 TREE_PUBLIC (type_decl
) = 1;
7956 determine_visibility (type_decl
);
7962 /* Wrapper for lookup_template_class_1. */
7965 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
7966 int entering_scope
, tsubst_flags_t complain
)
7969 timevar_push (TV_TEMPLATE_INST
);
7970 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
7971 entering_scope
, complain
);
7972 timevar_pop (TV_TEMPLATE_INST
);
7976 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
7977 If the ARGLIST refers to any template parameters, the type of the
7978 expression is the unknown_type_node since the template-id could
7979 refer to an explicit or partial specialization. */
7982 lookup_template_variable (tree templ
, tree arglist
)
7985 if (uses_template_parms (arglist
))
7986 type
= unknown_type_node
;
7988 type
= TREE_TYPE (templ
);
7989 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
7997 /* True when we should also visit template parameters that occur in
7998 non-deduced contexts. */
7999 bool include_nondeduced_p
;
8000 hash_set
<tree
> *visited
;
8003 /* Called from for_each_template_parm via walk_tree. */
8006 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
8009 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
8010 tree_fn_t fn
= pfd
->fn
;
8011 void *data
= pfd
->data
;
8014 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
8015 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
8016 pfd
->include_nondeduced_p
))
8017 return error_mark_node
;
8019 switch (TREE_CODE (t
))
8022 if (TYPE_PTRMEMFUNC_P (t
))
8028 if (!TYPE_TEMPLATE_INFO (t
))
8030 else if (for_each_template_parm (TYPE_TI_ARGS (t
),
8031 fn
, data
, pfd
->visited
,
8032 pfd
->include_nondeduced_p
))
8033 return error_mark_node
;
8037 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
8038 fn
, data
, pfd
->visited
,
8039 pfd
->include_nondeduced_p
)
8040 || for_each_template_parm (TYPE_MAX_VALUE (t
),
8041 fn
, data
, pfd
->visited
,
8042 pfd
->include_nondeduced_p
))
8043 return error_mark_node
;
8047 /* Since we're not going to walk subtrees, we have to do this
8049 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
8050 pfd
->visited
, pfd
->include_nondeduced_p
))
8051 return error_mark_node
;
8055 /* Check the return type. */
8056 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8057 pfd
->include_nondeduced_p
))
8058 return error_mark_node
;
8060 /* Check the parameter types. Since default arguments are not
8061 instantiated until they are needed, the TYPE_ARG_TYPES may
8062 contain expressions that involve template parameters. But,
8063 no-one should be looking at them yet. And, once they're
8064 instantiated, they don't contain template parameters, so
8065 there's no point in looking at them then, either. */
8069 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
8070 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
8071 pfd
->visited
, pfd
->include_nondeduced_p
))
8072 return error_mark_node
;
8074 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8075 want walk_tree walking into them itself. */
8081 case UNDERLYING_TYPE
:
8082 if (pfd
->include_nondeduced_p
8083 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
8085 pfd
->include_nondeduced_p
))
8086 return error_mark_node
;
8091 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
8092 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
8093 pfd
->visited
, pfd
->include_nondeduced_p
))
8094 return error_mark_node
;
8099 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
8100 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
8101 pfd
->visited
, pfd
->include_nondeduced_p
))
8102 return error_mark_node
;
8103 if (DECL_CONTEXT (t
)
8104 && pfd
->include_nondeduced_p
8105 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
8106 pfd
->visited
, pfd
->include_nondeduced_p
))
8107 return error_mark_node
;
8110 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8111 /* Record template parameters such as `T' inside `TT<T>'. */
8112 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
8113 pfd
->include_nondeduced_p
))
8114 return error_mark_node
;
8117 case TEMPLATE_TEMPLATE_PARM
:
8118 case TEMPLATE_TYPE_PARM
:
8119 case TEMPLATE_PARM_INDEX
:
8120 if (fn
&& (*fn
)(t
, data
))
8121 return error_mark_node
;
8123 return error_mark_node
;
8127 /* A template template parameter is encountered. */
8128 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
8129 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
8130 pfd
->include_nondeduced_p
))
8131 return error_mark_node
;
8133 /* Already substituted template template parameter */
8139 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
8141 pfd
->include_nondeduced_p
))
8142 return error_mark_node
;
8146 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
8147 && pfd
->include_nondeduced_p
8148 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8149 (TREE_TYPE (t
)), fn
, data
,
8150 pfd
->visited
, pfd
->include_nondeduced_p
))
8151 return error_mark_node
;
8156 /* If there's no type, then this thing must be some expression
8157 involving template parameters. */
8158 if (!fn
&& !TREE_TYPE (t
))
8159 return error_mark_node
;
8164 case IMPLICIT_CONV_EXPR
:
8165 case REINTERPRET_CAST_EXPR
:
8166 case CONST_CAST_EXPR
:
8167 case STATIC_CAST_EXPR
:
8168 case DYNAMIC_CAST_EXPR
:
8172 case PSEUDO_DTOR_EXPR
:
8174 return error_mark_node
;
8181 /* We didn't find any template parameters we liked. */
8185 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8186 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8187 call FN with the parameter and the DATA.
8188 If FN returns nonzero, the iteration is terminated, and
8189 for_each_template_parm returns 1. Otherwise, the iteration
8190 continues. If FN never returns a nonzero value, the value
8191 returned by for_each_template_parm is 0. If FN is NULL, it is
8192 considered to be the function which always returns 1.
8194 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8195 parameters that occur in non-deduced contexts. When false, only
8196 visits those template parameters that can be deduced. */
8199 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
8200 hash_set
<tree
> *visited
,
8201 bool include_nondeduced_p
)
8203 struct pair_fn_data pfd
;
8209 pfd
.include_nondeduced_p
= include_nondeduced_p
;
8211 /* Walk the tree. (Conceptually, we would like to walk without
8212 duplicates, but for_each_template_parm_r recursively calls
8213 for_each_template_parm, so we would need to reorganize a fair
8214 bit to use walk_tree_without_duplicates, so we keep our own
8217 pfd
.visited
= visited
;
8219 pfd
.visited
= new hash_set
<tree
>;
8220 result
= cp_walk_tree (&t
,
8221 for_each_template_parm_r
,
8223 pfd
.visited
) != NULL_TREE
;
8235 /* Returns true if T depends on any template parameter. */
8238 uses_template_parms (tree t
)
8241 int saved_processing_template_decl
;
8243 saved_processing_template_decl
= processing_template_decl
;
8244 if (!saved_processing_template_decl
)
8245 processing_template_decl
= 1;
8247 dependent_p
= dependent_type_p (t
);
8248 else if (TREE_CODE (t
) == TREE_VEC
)
8249 dependent_p
= any_dependent_template_arguments_p (t
);
8250 else if (TREE_CODE (t
) == TREE_LIST
)
8251 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
8252 || uses_template_parms (TREE_CHAIN (t
)));
8253 else if (TREE_CODE (t
) == TYPE_DECL
)
8254 dependent_p
= dependent_type_p (TREE_TYPE (t
));
8257 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
8258 || TREE_CODE (t
) == OVERLOAD
8261 || TREE_CODE (t
) == TRAIT_EXPR
8262 || TREE_CODE (t
) == CONSTRUCTOR
8263 || CONSTANT_CLASS_P (t
))
8264 dependent_p
= (type_dependent_expression_p (t
)
8265 || value_dependent_expression_p (t
));
8268 gcc_assert (t
== error_mark_node
);
8269 dependent_p
= false;
8272 processing_template_decl
= saved_processing_template_decl
;
8277 /* Returns true iff current_function_decl is an incompletely instantiated
8278 template. Useful instead of processing_template_decl because the latter
8279 is set to 0 during fold_non_dependent_expr. */
8282 in_template_function (void)
8284 tree fn
= current_function_decl
;
8286 ++processing_template_decl
;
8287 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
8288 && DECL_TEMPLATE_INFO (fn
)
8289 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
8290 --processing_template_decl
;
8294 /* Returns true if T depends on any template parameter with level LEVEL. */
8297 uses_template_parms_level (tree t
, int level
)
8299 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
8300 /*include_nondeduced_p=*/true);
8303 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8304 ill-formed translation unit, i.e. a variable or function that isn't
8305 usable in a constant expression. */
8308 neglectable_inst_p (tree d
)
8311 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
8312 : decl_maybe_constant_var_p (d
)));
8315 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8316 neglectable and instantiated from within an erroneous instantiation. */
8319 limit_bad_template_recursion (tree decl
)
8321 struct tinst_level
*lev
= current_tinst_level
;
8322 int errs
= errorcount
+ sorrycount
;
8323 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
8326 for (; lev
; lev
= lev
->next
)
8327 if (neglectable_inst_p (lev
->decl
))
8330 return (lev
&& errs
> lev
->errors
);
8333 static int tinst_depth
;
8334 extern int max_tinst_depth
;
8337 static GTY(()) struct tinst_level
*last_error_tinst_level
;
8339 /* We're starting to instantiate D; record the template instantiation context
8340 for diagnostics and to restore it later. */
8343 push_tinst_level (tree d
)
8345 struct tinst_level
*new_level
;
8347 if (tinst_depth
>= max_tinst_depth
)
8349 last_error_tinst_level
= current_tinst_level
;
8350 if (TREE_CODE (d
) == TREE_LIST
)
8351 error ("template instantiation depth exceeds maximum of %d (use "
8352 "-ftemplate-depth= to increase the maximum) substituting %qS",
8353 max_tinst_depth
, d
);
8355 error ("template instantiation depth exceeds maximum of %d (use "
8356 "-ftemplate-depth= to increase the maximum) instantiating %qD",
8357 max_tinst_depth
, d
);
8359 print_instantiation_context ();
8364 /* If the current instantiation caused problems, don't let it instantiate
8365 anything else. Do allow deduction substitution and decls usable in
8366 constant expressions. */
8367 if (limit_bad_template_recursion (d
))
8370 new_level
= ggc_alloc
<tinst_level
> ();
8371 new_level
->decl
= d
;
8372 new_level
->locus
= input_location
;
8373 new_level
->errors
= errorcount
+sorrycount
;
8374 new_level
->in_system_header_p
= in_system_header_at (input_location
);
8375 new_level
->next
= current_tinst_level
;
8376 current_tinst_level
= new_level
;
8379 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
8380 depth_reached
= tinst_depth
;
8385 /* We're done instantiating this template; return to the instantiation
8389 pop_tinst_level (void)
8391 /* Restore the filename and line number stashed away when we started
8392 this instantiation. */
8393 input_location
= current_tinst_level
->locus
;
8394 current_tinst_level
= current_tinst_level
->next
;
8398 /* We're instantiating a deferred template; restore the template
8399 instantiation context in which the instantiation was requested, which
8400 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8403 reopen_tinst_level (struct tinst_level
*level
)
8405 struct tinst_level
*t
;
8408 for (t
= level
; t
; t
= t
->next
)
8411 current_tinst_level
= level
;
8413 if (current_tinst_level
)
8414 current_tinst_level
->errors
= errorcount
+sorrycount
;
8418 /* Returns the TINST_LEVEL which gives the original instantiation
8421 struct tinst_level
*
8422 outermost_tinst_level (void)
8424 struct tinst_level
*level
= current_tinst_level
;
8427 level
= level
->next
;
8431 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8432 vector of template arguments, as for tsubst.
8434 Returns an appropriate tsubst'd friend declaration. */
8437 tsubst_friend_function (tree decl
, tree args
)
8441 if (TREE_CODE (decl
) == FUNCTION_DECL
8442 && DECL_TEMPLATE_INSTANTIATION (decl
)
8443 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
8444 /* This was a friend declared with an explicit template
8445 argument list, e.g.:
8449 to indicate that f was a template instantiation, not a new
8450 function declaration. Now, we have to figure out what
8451 instantiation of what template. */
8453 tree template_id
, arglist
, fns
;
8456 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
8458 /* Friend functions are looked up in the containing namespace scope.
8459 We must enter that scope, to avoid finding member functions of the
8460 current class with same name. */
8461 push_nested_namespace (ns
);
8462 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
8463 tf_warning_or_error
, NULL_TREE
,
8464 /*integral_constant_expression_p=*/false);
8465 pop_nested_namespace (ns
);
8466 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
8467 tf_warning_or_error
, NULL_TREE
);
8468 template_id
= lookup_template_function (fns
, arglist
);
8470 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8471 tmpl
= determine_specialization (template_id
, new_friend
,
8473 /*need_member_template=*/0,
8474 TREE_VEC_LENGTH (args
),
8476 return instantiate_template (tmpl
, new_args
, tf_error
);
8479 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
8481 /* The NEW_FRIEND will look like an instantiation, to the
8482 compiler, but is not an instantiation from the point of view of
8483 the language. For example, we might have had:
8485 template <class T> struct S {
8486 template <class U> friend void f(T, U);
8489 Then, in S<int>, template <class U> void f(int, U) is not an
8490 instantiation of anything. */
8491 if (new_friend
== error_mark_node
)
8492 return error_mark_node
;
8494 DECL_USE_TEMPLATE (new_friend
) = 0;
8495 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8497 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
8498 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
8499 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
8502 /* The mangled name for the NEW_FRIEND is incorrect. The function
8503 is not a template instantiation and should not be mangled like
8504 one. Therefore, we forget the mangling here; we'll recompute it
8505 later if we need it. */
8506 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
8508 SET_DECL_RTL (new_friend
, NULL
);
8509 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
8512 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
8515 tree new_friend_template_info
;
8516 tree new_friend_result_template_info
;
8518 int new_friend_is_defn
;
8520 /* We must save some information from NEW_FRIEND before calling
8521 duplicate decls since that function will free NEW_FRIEND if
8523 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
8524 new_friend_is_defn
=
8525 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8526 (template_for_substitution (new_friend
)))
8528 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
8530 /* This declaration is a `primary' template. */
8531 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
8533 new_friend_result_template_info
8534 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
8537 new_friend_result_template_info
= NULL_TREE
;
8539 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8540 if (new_friend_is_defn
)
8541 DECL_INITIAL (new_friend
) = error_mark_node
;
8543 /* Inside pushdecl_namespace_level, we will push into the
8544 current namespace. However, the friend function should go
8545 into the namespace of the template. */
8546 ns
= decl_namespace_context (new_friend
);
8547 push_nested_namespace (ns
);
8548 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
8549 pop_nested_namespace (ns
);
8551 if (old_decl
== error_mark_node
)
8552 return error_mark_node
;
8554 if (old_decl
!= new_friend
)
8556 /* This new friend declaration matched an existing
8557 declaration. For example, given:
8559 template <class T> void f(T);
8560 template <class U> class C {
8561 template <class T> friend void f(T) {}
8564 the friend declaration actually provides the definition
8565 of `f', once C has been instantiated for some type. So,
8566 old_decl will be the out-of-class template declaration,
8567 while new_friend is the in-class definition.
8569 But, if `f' was called before this point, the
8570 instantiation of `f' will have DECL_TI_ARGS corresponding
8571 to `T' but not to `U', references to which might appear
8572 in the definition of `f'. Previously, the most general
8573 template for an instantiation of `f' was the out-of-class
8574 version; now it is the in-class version. Therefore, we
8575 run through all specialization of `f', adding to their
8576 DECL_TI_ARGS appropriately. In particular, they need a
8577 new set of outer arguments, corresponding to the
8578 arguments for this class instantiation.
8580 The same situation can arise with something like this:
8583 template <class T> class C {
8587 when `C<int>' is instantiated. Now, `f(int)' is defined
8590 if (!new_friend_is_defn
)
8591 /* On the other hand, if the in-class declaration does
8592 *not* provide a definition, then we don't want to alter
8593 existing definitions. We can just leave everything
8598 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
8599 tree new_args
= TI_ARGS (new_friend_template_info
);
8601 /* Overwrite whatever template info was there before, if
8602 any, with the new template information pertaining to
8604 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
8606 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
8608 /* We should have called reregister_specialization in
8610 gcc_assert (retrieve_specialization (new_template
,
8614 /* Instantiate it if the global has already been used. */
8615 if (DECL_ODR_USED (old_decl
))
8616 instantiate_decl (old_decl
, /*defer_ok=*/true,
8617 /*expl_inst_class_mem_p=*/false);
8623 /* Indicate that the old function template is a partial
8625 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
8626 = new_friend_result_template_info
;
8628 gcc_assert (new_template
8629 == most_general_template (new_template
));
8630 gcc_assert (new_template
!= old_decl
);
8632 /* Reassign any specializations already in the hash table
8633 to the new more general template, and add the
8634 additional template args. */
8635 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
8639 tree spec
= TREE_VALUE (t
);
8642 elt
.tmpl
= old_decl
;
8643 elt
.args
= DECL_TI_ARGS (spec
);
8644 elt
.spec
= NULL_TREE
;
8646 htab_remove_elt (decl_specializations
, &elt
);
8649 = add_outermost_template_args (new_args
,
8650 DECL_TI_ARGS (spec
));
8652 register_specialization
8653 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
8656 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
8660 /* The information from NEW_FRIEND has been merged into OLD_DECL
8661 by duplicate_decls. */
8662 new_friend
= old_decl
;
8667 tree context
= DECL_CONTEXT (new_friend
);
8671 template <class T> class C {
8672 template <class U> friend void C1<U>::f (); // case 1
8673 friend void C2<T>::f (); // case 2
8675 we only need to make sure CONTEXT is a complete type for
8676 case 2. To distinguish between the two cases, we note that
8677 CONTEXT of case 1 remains dependent type after tsubst while
8678 this isn't true for case 2. */
8679 ++processing_template_decl
;
8680 dependent_p
= dependent_type_p (context
);
8681 --processing_template_decl
;
8684 && !complete_type_or_else (context
, NULL_TREE
))
8685 return error_mark_node
;
8687 if (COMPLETE_TYPE_P (context
))
8689 tree fn
= new_friend
;
8690 /* do_friend adds the TEMPLATE_DECL for any member friend
8691 template even if it isn't a member template, i.e.
8692 template <class T> friend A<T>::f();
8693 Look through it in that case. */
8694 if (TREE_CODE (fn
) == TEMPLATE_DECL
8695 && !PRIMARY_TEMPLATE_P (fn
))
8696 fn
= DECL_TEMPLATE_RESULT (fn
);
8697 /* Check to see that the declaration is really present, and,
8698 possibly obtain an improved declaration. */
8699 fn
= check_classfn (context
, fn
, NULL_TREE
);
8709 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8710 template arguments, as for tsubst.
8712 Returns an appropriate tsubst'd friend type or error_mark_node on
8716 tsubst_friend_class (tree friend_tmpl
, tree args
)
8722 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
8724 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
8725 return TREE_TYPE (t
);
8728 context
= CP_DECL_CONTEXT (friend_tmpl
);
8730 if (context
!= global_namespace
)
8732 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8733 push_nested_namespace (context
);
8735 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
8738 /* Look for a class template declaration. We look for hidden names
8739 because two friend declarations of the same template are the
8740 same. For example, in:
8743 template <typename> friend class F;
8745 template <typename> struct B {
8746 template <typename> friend class F;
8749 both F templates are the same. */
8750 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
8751 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
8753 /* But, if we don't find one, it might be because we're in a
8754 situation like this:
8762 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8763 for `S<int>', not the TEMPLATE_DECL. */
8764 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
8766 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
8767 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
8770 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
8772 /* The friend template has already been declared. Just
8773 check to see that the declarations match, and install any new
8774 default parameters. We must tsubst the default parameters,
8775 of course. We only need the innermost template parameters
8776 because that is all that redeclare_class_template will look
8778 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
8779 > TMPL_ARGS_DEPTH (args
))
8782 location_t saved_input_location
;
8783 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
8784 args
, tf_warning_or_error
);
8786 saved_input_location
= input_location
;
8787 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
8788 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
8789 input_location
= saved_input_location
;
8793 friend_type
= TREE_TYPE (tmpl
);
8797 /* The friend template has not already been declared. In this
8798 case, the instantiation of the template class will cause the
8799 injection of this template into the global scope. */
8800 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
8801 if (tmpl
== error_mark_node
)
8802 return error_mark_node
;
8804 /* The new TMPL is not an instantiation of anything, so we
8805 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8806 the new type because that is supposed to be the corresponding
8807 template decl, i.e., TMPL. */
8808 DECL_USE_TEMPLATE (tmpl
) = 0;
8809 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
8810 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
8811 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
8812 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
8814 /* Inject this template into the global scope. */
8815 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
8818 if (context
!= global_namespace
)
8820 if (TREE_CODE (context
) == NAMESPACE_DECL
)
8821 pop_nested_namespace (context
);
8823 pop_nested_class ();
8829 /* Returns zero if TYPE cannot be completed later due to circularity.
8830 Otherwise returns one. */
8833 can_complete_type_without_circularity (tree type
)
8835 if (type
== NULL_TREE
|| type
== error_mark_node
)
8837 else if (COMPLETE_TYPE_P (type
))
8839 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
8840 return can_complete_type_without_circularity (TREE_TYPE (type
));
8841 else if (CLASS_TYPE_P (type
)
8842 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
8848 static tree
tsubst_omp_clauses (tree
, bool, tree
, tsubst_flags_t
, tree
);
8850 /* Apply any attributes which had to be deferred until instantiation
8851 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8852 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8855 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
8856 tree args
, tsubst_flags_t complain
, tree in_decl
)
8858 tree last_dep
= NULL_TREE
;
8862 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
8863 if (ATTR_IS_DEPENDENT (t
))
8866 attributes
= copy_list (attributes
);
8870 if (DECL_P (*decl_p
))
8872 if (TREE_TYPE (*decl_p
) == error_mark_node
)
8874 p
= &DECL_ATTRIBUTES (*decl_p
);
8877 p
= &TYPE_ATTRIBUTES (*decl_p
);
8881 tree late_attrs
= NULL_TREE
;
8882 tree
*q
= &late_attrs
;
8884 for (*p
= attributes
; *p
; )
8887 if (ATTR_IS_DEPENDENT (t
))
8889 *p
= TREE_CHAIN (t
);
8890 TREE_CHAIN (t
) = NULL_TREE
;
8891 if ((flag_openmp
|| flag_cilkplus
)
8892 && is_attribute_p ("omp declare simd",
8893 get_attribute_name (t
))
8896 tree clauses
= TREE_VALUE (TREE_VALUE (t
));
8897 clauses
= tsubst_omp_clauses (clauses
, true, args
,
8899 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
8900 clauses
= finish_omp_clauses (clauses
);
8901 tree parms
= DECL_ARGUMENTS (*decl_p
);
8903 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
8905 TREE_VALUE (TREE_VALUE (t
)) = clauses
;
8907 TREE_VALUE (t
) = NULL_TREE
;
8909 /* If the first attribute argument is an identifier, don't
8910 pass it through tsubst. Attributes like mode, format,
8911 cleanup and several target specific attributes expect it
8913 else if (attribute_takes_identifier_p (get_attribute_name (t
))
8917 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
8919 /*integral_constant_expression_p=*/false);
8920 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
8922 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
8927 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
8928 /*integral_constant_expression_p=*/false);
8930 q
= &TREE_CHAIN (t
);
8933 p
= &TREE_CHAIN (t
);
8936 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
8940 /* Perform (or defer) access check for typedefs that were referenced
8941 from within the template TMPL code.
8942 This is a subroutine of instantiate_decl and instantiate_class_template.
8943 TMPL is the template to consider and TARGS is the list of arguments of
8947 perform_typedefs_access_check (tree tmpl
, tree targs
)
8949 location_t saved_location
;
8951 qualified_typedef_usage_t
*iter
;
8954 || (!CLASS_TYPE_P (tmpl
)
8955 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
8958 saved_location
= input_location
;
8959 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
8961 tree type_decl
= iter
->typedef_decl
;
8962 tree type_scope
= iter
->context
;
8964 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
8967 if (uses_template_parms (type_decl
))
8968 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
8969 if (uses_template_parms (type_scope
))
8970 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
8972 /* Make access check error messages point to the location
8973 of the use of the typedef. */
8974 input_location
= iter
->locus
;
8975 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
8976 type_decl
, type_decl
,
8977 tf_warning_or_error
);
8979 input_location
= saved_location
;
8983 instantiate_class_template_1 (tree type
)
8985 tree templ
, args
, pattern
, t
, member
;
8989 unsigned int saved_maximum_field_alignment
;
8992 if (type
== error_mark_node
)
8993 return error_mark_node
;
8995 if (COMPLETE_OR_OPEN_TYPE_P (type
)
8996 || uses_template_parms (type
))
8999 /* Figure out which template is being instantiated. */
9000 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
9001 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
9003 /* Determine what specialization of the original template to
9005 t
= most_specialized_class (type
, tf_warning_or_error
);
9006 if (t
== error_mark_node
)
9008 TYPE_BEING_DEFINED (type
) = 1;
9009 return error_mark_node
;
9013 /* This TYPE is actually an instantiation of a partial
9014 specialization. We replace the innermost set of ARGS with
9015 the arguments appropriate for substitution. For example,
9018 template <class T> struct S {};
9019 template <class T> struct S<T*> {};
9021 and supposing that we are instantiating S<int*>, ARGS will
9022 presently be {int*} -- but we need {int}. */
9023 pattern
= TREE_TYPE (t
);
9024 args
= TREE_PURPOSE (t
);
9028 pattern
= TREE_TYPE (templ
);
9029 args
= CLASSTYPE_TI_ARGS (type
);
9032 /* If the template we're instantiating is incomplete, then clearly
9033 there's nothing we can do. */
9034 if (!COMPLETE_TYPE_P (pattern
))
9037 /* If we've recursively instantiated too many templates, stop. */
9038 if (! push_tinst_level (type
))
9041 /* Now we're really doing the instantiation. Mark the type as in
9042 the process of being defined. */
9043 TYPE_BEING_DEFINED (type
) = 1;
9045 /* We may be in the middle of deferred access check. Disable
9047 push_deferring_access_checks (dk_no_deferred
);
9049 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
9050 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9051 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
9052 fn_context
= error_mark_node
;
9054 push_to_top_level ();
9055 /* Use #pragma pack from the template context. */
9056 saved_maximum_field_alignment
= maximum_field_alignment
;
9057 maximum_field_alignment
= TYPE_PRECISION (pattern
);
9059 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
9061 /* Set the input location to the most specialized template definition.
9062 This is needed if tsubsting causes an error. */
9063 typedecl
= TYPE_MAIN_DECL (pattern
);
9064 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
9065 DECL_SOURCE_LOCATION (typedecl
);
9067 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
9068 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
9069 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
9070 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
9071 if (ANON_AGGR_TYPE_P (pattern
))
9072 SET_ANON_AGGR_TYPE_P (type
);
9073 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
9075 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
9076 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
9077 /* Adjust visibility for template arguments. */
9078 determine_visibility (TYPE_MAIN_DECL (type
));
9080 if (CLASS_TYPE_P (type
))
9081 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
9083 pbinfo
= TYPE_BINFO (pattern
);
9085 /* We should never instantiate a nested class before its enclosing
9086 class; we need to look up the nested class by name before we can
9087 instantiate it, and that lookup should instantiate the enclosing
9089 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
9090 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
9092 base_list
= NULL_TREE
;
9093 if (BINFO_N_BASE_BINFOS (pbinfo
))
9099 /* We must enter the scope containing the type, as that is where
9100 the accessibility of types named in dependent bases are
9102 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
9104 /* Substitute into each of the bases to determine the actual
9106 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
9109 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
9110 tree expanded_bases
= NULL_TREE
;
9113 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
9116 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
9117 args
, tf_error
, NULL_TREE
);
9118 if (expanded_bases
== error_mark_node
)
9121 len
= TREE_VEC_LENGTH (expanded_bases
);
9124 for (idx
= 0; idx
< len
; idx
++)
9127 /* Extract the already-expanded base class. */
9128 base
= TREE_VEC_ELT (expanded_bases
, idx
);
9130 /* Substitute to figure out the base class. */
9131 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
9134 if (base
== error_mark_node
)
9137 base_list
= tree_cons (access
, base
, base_list
);
9138 if (BINFO_VIRTUAL_P (pbase_binfo
))
9139 TREE_TYPE (base_list
) = integer_type_node
;
9143 /* The list is now in reverse order; correct that. */
9144 base_list
= nreverse (base_list
);
9147 pop_scope (pushed_scope
);
9149 /* Now call xref_basetypes to set up all the base-class
9151 xref_basetypes (type
, base_list
);
9153 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
9154 (int) ATTR_FLAG_TYPE_IN_PLACE
,
9155 args
, tf_error
, NULL_TREE
);
9156 fixup_attribute_variants (type
);
9158 /* Now that our base classes are set up, enter the scope of the
9159 class, so that name lookups into base classes, etc. will work
9160 correctly. This is precisely analogous to what we do in
9161 begin_class_definition when defining an ordinary non-template
9162 class, except we also need to push the enclosing classes. */
9163 push_nested_class (type
);
9165 /* Now members are processed in the order of declaration. */
9166 for (member
= CLASSTYPE_DECL_LIST (pattern
);
9167 member
; member
= TREE_CHAIN (member
))
9169 tree t
= TREE_VALUE (member
);
9171 if (TREE_PURPOSE (member
))
9175 /* Build new CLASSTYPE_NESTED_UTDS. */
9178 bool class_template_p
;
9180 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
9181 && TYPE_LANG_SPECIFIC (t
)
9182 && CLASSTYPE_IS_TEMPLATE (t
));
9183 /* If the member is a class template, then -- even after
9184 substitution -- there may be dependent types in the
9185 template argument list for the class. We increment
9186 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9187 that function will assume that no types are dependent
9188 when outside of a template. */
9189 if (class_template_p
)
9190 ++processing_template_decl
;
9191 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9192 if (class_template_p
)
9193 --processing_template_decl
;
9194 if (newtag
== error_mark_node
)
9197 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
9199 tree name
= TYPE_IDENTIFIER (t
);
9201 if (class_template_p
)
9202 /* Unfortunately, lookup_template_class sets
9203 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9204 instantiation (i.e., for the type of a member
9205 template class nested within a template class.)
9206 This behavior is required for
9207 maybe_process_partial_specialization to work
9208 correctly, but is not accurate in this case;
9209 the TAG is not an instantiation of anything.
9210 (The corresponding TEMPLATE_DECL is an
9211 instantiation, but the TYPE is not.) */
9212 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
9214 /* Now, we call pushtag to put this NEWTAG into the scope of
9215 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9216 pushtag calling push_template_decl. We don't have to do
9217 this for enums because it will already have been done in
9220 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
9221 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
9224 else if (DECL_DECLARES_FUNCTION_P (t
))
9226 /* Build new TYPE_METHODS. */
9229 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9230 ++processing_template_decl
;
9231 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
9232 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9233 --processing_template_decl
;
9234 set_current_access_from_decl (r
);
9235 finish_member_declaration (r
);
9236 /* Instantiate members marked with attribute used. */
9237 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9239 if (TREE_CODE (r
) == FUNCTION_DECL
9240 && DECL_OMP_DECLARE_REDUCTION_P (r
))
9241 cp_check_omp_declare_reduction (r
);
9243 else if (DECL_CLASS_TEMPLATE_P (t
)
9244 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
9245 /* A closure type for a lambda in a default argument for a
9246 member template. Ignore it; it will be instantiated with
9247 the default argument. */;
9250 /* Build new TYPE_FIELDS. */
9251 if (TREE_CODE (t
) == STATIC_ASSERT
)
9255 ++c_inhibit_evaluation_warnings
;
9257 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
9258 tf_warning_or_error
, NULL_TREE
,
9259 /*integral_constant_expression_p=*/true);
9260 --c_inhibit_evaluation_warnings
;
9262 finish_static_assert (condition
,
9263 STATIC_ASSERT_MESSAGE (t
),
9264 STATIC_ASSERT_SOURCE_LOCATION (t
),
9267 else if (TREE_CODE (t
) != CONST_DECL
)
9270 tree vec
= NULL_TREE
;
9273 /* The file and line for this declaration, to
9274 assist in error message reporting. Since we
9275 called push_tinst_level above, we don't need to
9277 input_location
= DECL_SOURCE_LOCATION (t
);
9279 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9280 ++processing_template_decl
;
9281 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
9282 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9283 --processing_template_decl
;
9285 if (TREE_CODE (r
) == TREE_VEC
)
9287 /* A capture pack became multiple fields. */
9289 len
= TREE_VEC_LENGTH (vec
);
9292 for (int i
= 0; i
< len
; ++i
)
9295 r
= TREE_VEC_ELT (vec
, i
);
9300 [t]he initialization (and any associated
9301 side-effects) of a static data member does
9302 not occur unless the static data member is
9303 itself used in a way that requires the
9304 definition of the static data member to
9307 Therefore, we do not substitute into the
9308 initialized for the static data member here. */
9309 finish_static_data_member_decl
9312 /*init_const_expr_p=*/false,
9313 /*asmspec_tree=*/NULL_TREE
,
9315 /* Instantiate members marked with attribute used. */
9316 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
9319 else if (TREE_CODE (r
) == FIELD_DECL
)
9321 /* Determine whether R has a valid type and can be
9322 completed later. If R is invalid, then its type
9323 is replaced by error_mark_node. */
9324 tree rtype
= TREE_TYPE (r
);
9325 if (can_complete_type_without_circularity (rtype
))
9326 complete_type (rtype
);
9328 if (!COMPLETE_TYPE_P (rtype
))
9330 cxx_incomplete_type_error (r
, rtype
);
9331 TREE_TYPE (r
) = error_mark_node
;
9335 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9336 such a thing will already have been added to the field
9337 list by tsubst_enum in finish_member_declaration in the
9338 CLASSTYPE_NESTED_UTDS case above. */
9339 if (!(TREE_CODE (r
) == TYPE_DECL
9340 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
9341 && DECL_ARTIFICIAL (r
)))
9343 set_current_access_from_decl (r
);
9344 finish_member_declaration (r
);
9352 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
9353 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9355 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9357 tree friend_type
= t
;
9358 bool adjust_processing_template_decl
= false;
9360 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9362 /* template <class T> friend class C; */
9363 friend_type
= tsubst_friend_class (friend_type
, args
);
9364 adjust_processing_template_decl
= true;
9366 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
9368 /* template <class T> friend class C::D; */
9369 friend_type
= tsubst (friend_type
, args
,
9370 tf_warning_or_error
, NULL_TREE
);
9371 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
9372 friend_type
= TREE_TYPE (friend_type
);
9373 adjust_processing_template_decl
= true;
9375 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
9376 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
9378 /* This could be either
9382 when dependent_type_p is false or
9384 template <class U> friend class T::C;
9387 friend_type
= tsubst (friend_type
, args
,
9388 tf_warning_or_error
, NULL_TREE
);
9389 /* Bump processing_template_decl for correct
9390 dependent_type_p calculation. */
9391 ++processing_template_decl
;
9392 if (dependent_type_p (friend_type
))
9393 adjust_processing_template_decl
= true;
9394 --processing_template_decl
;
9396 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
9397 && hidden_name_p (TYPE_NAME (friend_type
)))
9401 where C hasn't been declared yet. Let's lookup name
9402 from namespace scope directly, bypassing any name that
9403 come from dependent base class. */
9404 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
9406 /* The call to xref_tag_from_type does injection for friend
9408 push_nested_namespace (ns
);
9410 xref_tag_from_type (friend_type
, NULL_TREE
,
9411 /*tag_scope=*/ts_current
);
9412 pop_nested_namespace (ns
);
9414 else if (uses_template_parms (friend_type
))
9415 /* friend class C<T>; */
9416 friend_type
= tsubst (friend_type
, args
,
9417 tf_warning_or_error
, NULL_TREE
);
9422 where C is already declared or
9424 friend class C<int>;
9426 We don't have to do anything in these cases. */
9428 if (adjust_processing_template_decl
)
9429 /* Trick make_friend_class into realizing that the friend
9430 we're adding is a template, not an ordinary class. It's
9431 important that we use make_friend_class since it will
9432 perform some error-checking and output cross-reference
9434 ++processing_template_decl
;
9436 if (friend_type
!= error_mark_node
)
9437 make_friend_class (type
, friend_type
, /*complain=*/false);
9439 if (adjust_processing_template_decl
)
9440 --processing_template_decl
;
9444 /* Build new DECL_FRIENDLIST. */
9447 /* The file and line for this declaration, to
9448 assist in error message reporting. Since we
9449 called push_tinst_level above, we don't need to
9451 input_location
= DECL_SOURCE_LOCATION (t
);
9453 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9455 ++processing_template_decl
;
9456 push_deferring_access_checks (dk_no_check
);
9459 r
= tsubst_friend_function (t
, args
);
9460 add_friend (type
, r
, /*complain=*/false);
9461 if (TREE_CODE (t
) == TEMPLATE_DECL
)
9463 pop_deferring_access_checks ();
9464 --processing_template_decl
;
9470 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
9472 tree decl
= lambda_function (type
);
9475 if (!DECL_TEMPLATE_INFO (decl
)
9476 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
9477 instantiate_decl (decl
, false, false);
9479 /* We need to instantiate the capture list from the template
9480 after we've instantiated the closure members, but before we
9481 consider adding the conversion op. Also keep any captures
9482 that may have been added during instantiation of the op(). */
9483 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
9485 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
9486 args
, tf_warning_or_error
, NULL_TREE
,
9489 LAMBDA_EXPR_CAPTURE_LIST (expr
)
9490 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
9492 maybe_add_lambda_conv_op (type
);
9495 gcc_assert (errorcount
);
9498 /* Set the file and line number information to whatever is given for
9499 the class itself. This puts error messages involving generated
9500 implicit functions at a predictable point, and the same point
9501 that would be used for non-template classes. */
9502 input_location
= DECL_SOURCE_LOCATION (typedecl
);
9504 unreverse_member_declarations (type
);
9505 finish_struct_1 (type
);
9506 TYPE_BEING_DEFINED (type
) = 0;
9508 /* We don't instantiate default arguments for member functions. 14.7.1:
9510 The implicit instantiation of a class template specialization causes
9511 the implicit instantiation of the declarations, but not of the
9512 definitions or default arguments, of the class member functions,
9513 member classes, static data members and member templates.... */
9515 /* Some typedefs referenced from within the template code need to be access
9516 checked at template instantiation time, i.e now. These types were
9517 added to the template at parsing time. Let's get those and perform
9518 the access checks then. */
9519 perform_typedefs_access_check (pattern
, args
);
9520 perform_deferred_access_checks (tf_warning_or_error
);
9521 pop_nested_class ();
9522 maximum_field_alignment
= saved_maximum_field_alignment
;
9524 pop_from_top_level ();
9525 pop_deferring_access_checks ();
9528 /* The vtable for a template class can be emitted in any translation
9529 unit in which the class is instantiated. When there is no key
9530 method, however, finish_struct_1 will already have added TYPE to
9531 the keyed_classes list. */
9532 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
9533 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
9538 /* Wrapper for instantiate_class_template_1. */
9541 instantiate_class_template (tree type
)
9544 timevar_push (TV_TEMPLATE_INST
);
9545 ret
= instantiate_class_template_1 (type
);
9546 timevar_pop (TV_TEMPLATE_INST
);
9551 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9557 else if (TYPE_P (t
))
9558 r
= tsubst (t
, args
, complain
, in_decl
);
9561 if (!(complain
& tf_warning
))
9562 ++c_inhibit_evaluation_warnings
;
9563 r
= tsubst_expr (t
, args
, complain
, in_decl
,
9564 /*integral_constant_expression_p=*/true);
9565 if (!(complain
& tf_warning
))
9566 --c_inhibit_evaluation_warnings
;
9571 /* Given a function parameter pack TMPL_PARM and some function parameters
9572 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9573 and set *SPEC_P to point at the next point in the list. */
9576 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
9578 /* Collect all of the extra "packed" parameters into an
9582 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
9583 tree argtypepack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
9584 tree spec_parm
= *spec_p
;
9587 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
9589 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
9592 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9593 parmvec
= make_tree_vec (len
);
9594 parmtypevec
= make_tree_vec (len
);
9595 spec_parm
= *spec_p
;
9596 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
9598 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
9599 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
9602 /* Build the argument packs. */
9603 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
9604 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
9605 TREE_TYPE (argpack
) = argtypepack
;
9606 *spec_p
= spec_parm
;
9611 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9612 NONTYPE_ARGUMENT_PACK. */
9615 make_fnparm_pack (tree spec_parm
)
9617 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
9620 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9624 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
9626 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
9627 if (i
>= TREE_VEC_LENGTH (vec
))
9629 return PACK_EXPANSION_P (TREE_VEC_ELT (vec
, i
));
9633 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9636 make_argument_pack_select (tree arg_pack
, unsigned index
)
9638 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
9640 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
9641 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9646 /* This is a subroutine of tsubst_pack_expansion.
9648 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9649 mechanism to store the (non complete list of) arguments of the
9650 substitution and return a non substituted pack expansion, in order
9651 to wait for when we have enough arguments to really perform the
9655 use_pack_expansion_extra_args_p (tree parm_packs
,
9659 /* If one pack has an expansion and another pack has a normal
9660 argument or if one pack has an empty argument and an another
9661 one hasn't then tsubst_pack_expansion cannot perform the
9662 substitution and need to fall back on the
9663 PACK_EXPANSION_EXTRA mechanism. */
9664 if (parm_packs
== NULL_TREE
)
9666 else if (has_empty_arg
)
9669 bool has_expansion_arg
= false;
9670 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
9672 bool has_non_expansion_arg
= false;
9673 for (tree parm_pack
= parm_packs
;
9675 parm_pack
= TREE_CHAIN (parm_pack
))
9677 tree arg
= TREE_VALUE (parm_pack
);
9679 if (argument_pack_element_is_expansion_p (arg
, i
))
9680 has_expansion_arg
= true;
9682 has_non_expansion_arg
= true;
9685 if (has_expansion_arg
&& has_non_expansion_arg
)
9691 /* [temp.variadic]/6 says that:
9693 The instantiation of a pack expansion [...]
9694 produces a list E1,E2, ..., En, where N is the number of elements
9695 in the pack expansion parameters.
9697 This subroutine of tsubst_pack_expansion produces one of these Ei.
9699 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9700 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9701 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9702 INDEX is the index 'i' of the element Ei to produce. ARGS,
9703 COMPLAIN, and IN_DECL are the same parameters as for the
9704 tsubst_pack_expansion function.
9706 The function returns the resulting Ei upon successful completion,
9709 Note that this function possibly modifies the ARGS parameter, so
9710 it's the responsibility of the caller to restore it. */
9713 gen_elem_of_pack_expansion_instantiation (tree pattern
,
9716 tree args
/* This parm gets
9718 tsubst_flags_t complain
,
9722 bool ith_elem_is_expansion
= false;
9724 /* For each parameter pack, change the substitution of the parameter
9725 pack to the ith argument in its argument pack, then expand the
9727 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
9729 tree parm
= TREE_PURPOSE (pack
);
9730 tree arg_pack
= TREE_VALUE (pack
);
9731 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
9733 ith_elem_is_expansion
|=
9734 argument_pack_element_is_expansion_p (arg_pack
, index
);
9736 /* Select the Ith argument from the pack. */
9737 if (TREE_CODE (parm
) == PARM_DECL
9738 || TREE_CODE (parm
) == FIELD_DECL
)
9742 aps
= make_argument_pack_select (arg_pack
, index
);
9744 register_local_specialization (aps
, parm
);
9747 aps
= retrieve_local_specialization (parm
);
9752 template_parm_level_and_index (parm
, &level
, &idx
);
9756 aps
= make_argument_pack_select (arg_pack
, index
);
9757 /* Update the corresponding argument. */
9758 TMPL_ARG (args
, level
, idx
) = aps
;
9761 /* Re-use the ARGUMENT_PACK_SELECT. */
9762 aps
= TMPL_ARG (args
, level
, idx
);
9764 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
9767 /* Substitute into the PATTERN with the (possibly altered)
9769 if (pattern
== in_decl
)
9770 /* Expanding a fixed parameter pack from
9771 coerce_template_parameter_pack. */
9772 t
= tsubst_decl (pattern
, args
, complain
);
9773 else if (!TYPE_P (pattern
))
9774 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9775 /*integral_constant_expression_p=*/false);
9777 t
= tsubst (pattern
, args
, complain
, in_decl
);
9779 /* If the Ith argument pack element is a pack expansion, then
9780 the Ith element resulting from the substituting is going to
9781 be a pack expansion as well. */
9782 if (ith_elem_is_expansion
)
9783 t
= make_pack_expansion (t
);
9788 /* Substitute ARGS into T, which is an pack expansion
9789 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9790 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9791 (if only a partial substitution could be performed) or
9792 ERROR_MARK_NODE if there was an error. */
9794 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
9798 tree pack
, packs
= NULL_TREE
;
9799 bool unsubstituted_packs
= false;
9802 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
9803 bool need_local_specializations
= false;
9806 gcc_assert (PACK_EXPANSION_P (t
));
9807 pattern
= PACK_EXPANSION_PATTERN (t
);
9809 /* Add in any args remembered from an earlier partial instantiation. */
9810 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
9812 levels
= TMPL_ARGS_DEPTH (args
);
9814 /* Determine the argument packs that will instantiate the parameter
9815 packs used in the expansion expression. While we're at it,
9816 compute the number of arguments to be expanded and make sure it
9818 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
9819 pack
= TREE_CHAIN (pack
))
9821 tree parm_pack
= TREE_VALUE (pack
);
9822 tree arg_pack
= NULL_TREE
;
9823 tree orig_arg
= NULL_TREE
;
9826 if (TREE_CODE (parm_pack
) == BASES
)
9828 if (BASES_DIRECT (parm_pack
))
9829 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9830 args
, complain
, in_decl
, false));
9832 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
9833 args
, complain
, in_decl
, false));
9835 if (TREE_CODE (parm_pack
) == PARM_DECL
)
9837 if (PACK_EXPANSION_LOCAL_P (t
))
9838 arg_pack
= retrieve_local_specialization (parm_pack
);
9841 /* We can't rely on local_specializations for a parameter
9842 name used later in a function declaration (such as in a
9843 late-specified return type). Even if it exists, it might
9844 have the wrong value for a recursive call. Just make a
9845 dummy decl, since it's only used for its type. */
9846 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
9847 if (arg_pack
&& DECL_PACK_P (arg_pack
))
9848 /* Partial instantiation of the parm_pack, we can't build
9849 up an argument pack yet. */
9850 arg_pack
= NULL_TREE
;
9852 arg_pack
= make_fnparm_pack (arg_pack
);
9853 need_local_specializations
= true;
9856 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
9857 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
9861 template_parm_level_and_index (parm_pack
, &level
, &idx
);
9863 if (level
<= levels
)
9864 arg_pack
= TMPL_ARG (args
, level
, idx
);
9867 orig_arg
= arg_pack
;
9868 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
9869 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
9871 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
9872 /* This can only happen if we forget to expand an argument
9873 pack somewhere else. Just return an error, silently. */
9875 result
= make_tree_vec (1);
9876 TREE_VEC_ELT (result
, 0) = error_mark_node
;
9883 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
9885 /* Don't bother trying to do a partial substitution with
9886 incomplete packs; we'll try again after deduction. */
9887 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
9892 else if (len
!= my_len
)
9894 if (!(complain
& tf_error
))
9895 /* Fail quietly. */;
9896 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
9897 error ("mismatched argument pack lengths while expanding "
9901 error ("mismatched argument pack lengths while expanding "
9904 return error_mark_node
;
9907 /* Keep track of the parameter packs and their corresponding
9909 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
9910 TREE_TYPE (packs
) = orig_arg
;
9914 /* We can't substitute for this parameter pack. We use a flag as
9915 well as the missing_level counter because function parameter
9916 packs don't have a level. */
9917 unsubstituted_packs
= true;
9921 /* We cannot expand this expansion expression, because we don't have
9922 all of the argument packs we need. */
9923 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
9925 /* We got some full packs, but we can't substitute them in until we
9926 have values for all the packs. So remember these until then. */
9928 t
= make_pack_expansion (pattern
);
9929 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
9932 else if (unsubstituted_packs
)
9934 /* There were no real arguments, we're just replacing a parameter
9935 pack with another version of itself. Substitute into the
9936 pattern and return a PACK_EXPANSION_*. The caller will need to
9938 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
9939 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
9940 /*integral_constant_expression_p=*/false);
9942 t
= tsubst (pattern
, args
, complain
, in_decl
);
9943 t
= make_pack_expansion (t
);
9947 gcc_assert (len
>= 0);
9949 if (need_local_specializations
)
9951 /* We're in a late-specified return type, so create our own local
9952 specializations map; the current map is either NULL or (in the
9953 case of recursive unification) might have bindings that we don't
9954 want to use or alter. */
9955 saved_local_specializations
= local_specializations
;
9956 local_specializations
= new hash_map
<tree
, tree
>;
9959 /* For each argument in each argument pack, substitute into the
9961 result
= make_tree_vec (len
);
9962 for (i
= 0; i
< len
; ++i
)
9964 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
9968 TREE_VEC_ELT (result
, i
) = t
;
9969 if (t
== error_mark_node
)
9971 result
= error_mark_node
;
9976 /* Update ARGS to restore the substitution from parameter packs to
9977 their argument packs. */
9978 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
9980 tree parm
= TREE_PURPOSE (pack
);
9982 if (TREE_CODE (parm
) == PARM_DECL
9983 || TREE_CODE (parm
) == FIELD_DECL
)
9984 register_local_specialization (TREE_TYPE (pack
), parm
);
9989 if (TREE_VALUE (pack
) == NULL_TREE
)
9992 template_parm_level_and_index (parm
, &level
, &idx
);
9994 /* Update the corresponding argument. */
9995 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
9996 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
9999 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
10003 if (need_local_specializations
)
10005 delete local_specializations
;
10006 local_specializations
= saved_local_specializations
;
10012 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10013 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10014 parameter packs; all parms generated from a function parameter pack will
10015 have the same DECL_PARM_INDEX. */
10018 get_pattern_parm (tree parm
, tree tmpl
)
10020 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
10023 if (DECL_ARTIFICIAL (parm
))
10025 for (patparm
= DECL_ARGUMENTS (pattern
);
10026 patparm
; patparm
= DECL_CHAIN (patparm
))
10027 if (DECL_ARTIFICIAL (patparm
)
10028 && DECL_NAME (parm
) == DECL_NAME (patparm
))
10033 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
10034 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
10035 gcc_assert (DECL_PARM_INDEX (patparm
)
10036 == DECL_PARM_INDEX (parm
));
10042 /* Substitute ARGS into the vector or list of template arguments T. */
10045 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10048 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
10051 if (t
== error_mark_node
)
10052 return error_mark_node
;
10054 len
= TREE_VEC_LENGTH (t
);
10055 elts
= XALLOCAVEC (tree
, len
);
10057 for (i
= 0; i
< len
; i
++)
10059 tree orig_arg
= TREE_VEC_ELT (t
, i
);
10062 if (TREE_CODE (orig_arg
) == TREE_VEC
)
10063 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
10064 else if (PACK_EXPANSION_P (orig_arg
))
10066 /* Substitute into an expansion expression. */
10067 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
10069 if (TREE_CODE (new_arg
) == TREE_VEC
)
10070 /* Add to the expanded length adjustment the number of
10071 expanded arguments. We subtract one from this
10072 measurement, because the argument pack expression
10073 itself is already counted as 1 in
10074 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10075 the argument pack is empty. */
10076 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
10078 else if (ARGUMENT_PACK_P (orig_arg
))
10080 /* Substitute into each of the arguments. */
10081 new_arg
= TYPE_P (orig_arg
)
10082 ? cxx_make_type (TREE_CODE (orig_arg
))
10083 : make_node (TREE_CODE (orig_arg
));
10085 SET_ARGUMENT_PACK_ARGS (
10087 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
10088 args
, complain
, in_decl
));
10090 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
10091 new_arg
= error_mark_node
;
10093 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
10094 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
10095 complain
, in_decl
);
10096 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
10098 if (TREE_TYPE (new_arg
) == error_mark_node
)
10099 new_arg
= error_mark_node
;
10103 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
10105 if (new_arg
== error_mark_node
)
10106 return error_mark_node
;
10109 if (new_arg
!= orig_arg
)
10116 /* Make space for the expanded arguments coming from template
10118 t
= make_tree_vec (len
+ expanded_len_adjust
);
10119 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10120 arguments for a member template.
10121 In that case each TREE_VEC in ORIG_T represents a level of template
10122 arguments, and ORIG_T won't carry any non defaulted argument count.
10123 It will rather be the nested TREE_VECs that will carry one.
10124 In other words, ORIG_T carries a non defaulted argument count only
10125 if it doesn't contain any nested TREE_VEC. */
10126 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
10128 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
10129 count
+= expanded_len_adjust
;
10130 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
10132 for (i
= 0, out
= 0; i
< len
; i
++)
10134 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
10135 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
10136 && TREE_CODE (elts
[i
]) == TREE_VEC
)
10140 /* Now expand the template argument pack "in place". */
10141 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
10142 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
10146 TREE_VEC_ELT (t
, out
) = elts
[i
];
10154 /* Return the result of substituting ARGS into the template parameters
10155 given by PARMS. If there are m levels of ARGS and m + n levels of
10156 PARMS, then the result will contain n levels of PARMS. For
10157 example, if PARMS is `template <class T> template <class U>
10158 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10159 result will be `template <int*, double, class V>'. */
10162 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
10164 tree r
= NULL_TREE
;
10167 /* When substituting into a template, we must set
10168 PROCESSING_TEMPLATE_DECL as the template parameters may be
10169 dependent if they are based on one-another, and the dependency
10170 predicates are short-circuit outside of templates. */
10171 ++processing_template_decl
;
10173 for (new_parms
= &r
;
10174 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
10175 new_parms
= &(TREE_CHAIN (*new_parms
)),
10176 parms
= TREE_CHAIN (parms
))
10179 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
10182 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
10186 if (parms
== error_mark_node
)
10189 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
10191 if (tuple
== error_mark_node
)
10194 TREE_VEC_ELT (new_vec
, i
) =
10195 tsubst_template_parm (tuple
, args
, complain
);
10199 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
10200 - TMPL_ARGS_DEPTH (args
)),
10201 new_vec
, NULL_TREE
);
10204 --processing_template_decl
;
10209 /* Return the result of substituting ARGS into one template parameter
10210 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10211 parameter and which TREE_PURPOSE is the default argument of the
10212 template parameter. */
10215 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
10217 tree default_value
, parm_decl
;
10219 if (args
== NULL_TREE
10221 || t
== error_mark_node
)
10224 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
10226 default_value
= TREE_PURPOSE (t
);
10227 parm_decl
= TREE_VALUE (t
);
10229 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
10230 if (TREE_CODE (parm_decl
) == PARM_DECL
10231 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
10232 parm_decl
= error_mark_node
;
10233 default_value
= tsubst_template_arg (default_value
, args
,
10234 complain
, NULL_TREE
);
10236 return build_tree_list (default_value
, parm_decl
);
10239 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10240 type T. If T is not an aggregate or enumeration type, it is
10241 handled as if by tsubst. IN_DECL is as for tsubst. If
10242 ENTERING_SCOPE is nonzero, T is the context for a template which
10243 we are presently tsubst'ing. Return the substituted value. */
10246 tsubst_aggr_type (tree t
,
10248 tsubst_flags_t complain
,
10250 int entering_scope
)
10252 if (t
== NULL_TREE
)
10255 switch (TREE_CODE (t
))
10258 if (TYPE_PTRMEMFUNC_P (t
))
10259 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
10261 /* Else fall through. */
10262 case ENUMERAL_TYPE
:
10264 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
10269 int saved_unevaluated_operand
;
10270 int saved_inhibit_evaluation_warnings
;
10272 /* In "sizeof(X<I>)" we need to evaluate "I". */
10273 saved_unevaluated_operand
= cp_unevaluated_operand
;
10274 cp_unevaluated_operand
= 0;
10275 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10276 c_inhibit_evaluation_warnings
= 0;
10278 /* First, determine the context for the type we are looking
10280 context
= TYPE_CONTEXT (t
);
10281 if (context
&& TYPE_P (context
))
10283 context
= tsubst_aggr_type (context
, args
, complain
,
10284 in_decl
, /*entering_scope=*/1);
10285 /* If context is a nested class inside a class template,
10286 it may still need to be instantiated (c++/33959). */
10287 context
= complete_type (context
);
10290 /* Then, figure out what arguments are appropriate for the
10291 type we are trying to find. For example, given:
10293 template <class T> struct S;
10294 template <class T, class U> void f(T, U) { S<U> su; }
10296 and supposing that we are instantiating f<int, double>,
10297 then our ARGS will be {int, double}, but, when looking up
10298 S we only want {double}. */
10299 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
10300 complain
, in_decl
);
10301 if (argvec
== error_mark_node
)
10302 r
= error_mark_node
;
10305 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
10306 entering_scope
, complain
);
10307 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
10310 cp_unevaluated_operand
= saved_unevaluated_operand
;
10311 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10316 /* This is not a template type, so there's nothing to do. */
10320 return tsubst (t
, args
, complain
, in_decl
);
10324 /* Substitute into the default argument ARG (a default argument for
10325 FN), which has the indicated TYPE. */
10328 tsubst_default_argument (tree fn
, tree type
, tree arg
, tsubst_flags_t complain
)
10330 tree saved_class_ptr
= NULL_TREE
;
10331 tree saved_class_ref
= NULL_TREE
;
10332 int errs
= errorcount
+ sorrycount
;
10334 /* This can happen in invalid code. */
10335 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10338 /* This default argument came from a template. Instantiate the
10339 default argument here, not in tsubst. In the case of
10348 we must be careful to do name lookup in the scope of S<T>,
10349 rather than in the current class. */
10350 push_access_scope (fn
);
10351 /* The "this" pointer is not valid in a default argument. */
10354 saved_class_ptr
= current_class_ptr
;
10355 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
10356 saved_class_ref
= current_class_ref
;
10357 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
10360 push_deferring_access_checks(dk_no_deferred
);
10361 /* The default argument expression may cause implicitly defined
10362 member functions to be synthesized, which will result in garbage
10363 collection. We must treat this situation as if we were within
10364 the body of function so as to avoid collecting live data on the
10367 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
10368 complain
, NULL_TREE
,
10369 /*integral_constant_expression_p=*/false);
10371 pop_deferring_access_checks();
10373 /* Restore the "this" pointer. */
10376 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
10377 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
10380 if (errorcount
+sorrycount
> errs
10381 && (complain
& tf_warning_or_error
))
10382 inform (input_location
,
10383 " when instantiating default argument for call to %D", fn
);
10385 /* Make sure the default argument is reasonable. */
10386 arg
= check_default_argument (type
, arg
, complain
);
10388 pop_access_scope (fn
);
10393 /* Substitute into all the default arguments for FN. */
10396 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
10401 tmpl_args
= DECL_TI_ARGS (fn
);
10403 /* If this function is not yet instantiated, we certainly don't need
10404 its default arguments. */
10405 if (uses_template_parms (tmpl_args
))
10407 /* Don't do this again for clones. */
10408 if (DECL_CLONED_FUNCTION_P (fn
))
10411 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
10413 arg
= TREE_CHAIN (arg
))
10414 if (TREE_PURPOSE (arg
))
10415 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
10417 TREE_PURPOSE (arg
),
10421 /* Substitute the ARGS into the T, which is a _DECL. Return the
10422 result of the substitution. Issue error and warning messages under
10423 control of COMPLAIN. */
10426 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
10428 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10429 location_t saved_loc
;
10430 tree r
= NULL_TREE
;
10432 hashval_t hash
= 0;
10434 /* Set the filename and linenumber to improve error-reporting. */
10435 saved_loc
= input_location
;
10436 input_location
= DECL_SOURCE_LOCATION (t
);
10438 switch (TREE_CODE (t
))
10440 case TEMPLATE_DECL
:
10442 /* We can get here when processing a member function template,
10443 member class template, or template template parameter. */
10444 tree decl
= DECL_TEMPLATE_RESULT (t
);
10449 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10451 /* Template template parameter is treated here. */
10452 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10453 if (new_type
== error_mark_node
)
10454 RETURN (error_mark_node
);
10455 /* If we get a real template back, return it. This can happen in
10456 the context of most_specialized_class. */
10457 if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
10461 DECL_CHAIN (r
) = NULL_TREE
;
10462 TREE_TYPE (r
) = new_type
;
10463 DECL_TEMPLATE_RESULT (r
)
10464 = build_decl (DECL_SOURCE_LOCATION (decl
),
10465 TYPE_DECL
, DECL_NAME (decl
), new_type
);
10466 DECL_TEMPLATE_PARMS (r
)
10467 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10469 TYPE_NAME (new_type
) = r
;
10473 /* We might already have an instance of this template.
10474 The ARGS are for the surrounding class type, so the
10475 full args contain the tsubst'd args for the context,
10476 plus the innermost args from the template decl. */
10477 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
10478 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
10479 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
10480 /* Because this is a template, the arguments will still be
10481 dependent, even after substitution. If
10482 PROCESSING_TEMPLATE_DECL is not set, the dependency
10483 predicates will short-circuit. */
10484 ++processing_template_decl
;
10485 full_args
= tsubst_template_args (tmpl_args
, args
,
10486 complain
, in_decl
);
10487 --processing_template_decl
;
10488 if (full_args
== error_mark_node
)
10489 RETURN (error_mark_node
);
10491 /* If this is a default template template argument,
10492 tsubst might not have changed anything. */
10493 if (full_args
== tmpl_args
)
10496 hash
= hash_tmpl_and_args (t
, full_args
);
10497 spec
= retrieve_specialization (t
, full_args
, hash
);
10498 if (spec
!= NULL_TREE
)
10504 /* Make a new template decl. It will be similar to the
10505 original, but will record the current template arguments.
10506 We also create a new function declaration, which is just
10507 like the old one, but points to this new template, rather
10508 than the old one. */
10510 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
10511 DECL_CHAIN (r
) = NULL_TREE
;
10513 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
10515 if (TREE_CODE (decl
) == TYPE_DECL
10516 && !TYPE_DECL_ALIAS_P (decl
))
10519 ++processing_template_decl
;
10520 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10521 --processing_template_decl
;
10522 if (new_type
== error_mark_node
)
10523 RETURN (error_mark_node
);
10525 TREE_TYPE (r
) = new_type
;
10526 /* For a partial specialization, we need to keep pointing to
10527 the primary template. */
10528 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
10529 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
10530 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
10531 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
10532 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
10537 ++processing_template_decl
;
10538 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
10539 --processing_template_decl
;
10540 if (new_decl
== error_mark_node
)
10541 RETURN (error_mark_node
);
10543 DECL_TEMPLATE_RESULT (r
) = new_decl
;
10544 DECL_TI_TEMPLATE (new_decl
) = r
;
10545 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
10546 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
10547 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
10550 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10551 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
10552 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
10554 /* The template parameters for this new template are all the
10555 template parameters for the old template, except the
10556 outermost level of parameters. */
10557 DECL_TEMPLATE_PARMS (r
)
10558 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
10561 if (PRIMARY_TEMPLATE_P (t
))
10562 DECL_PRIMARY_TEMPLATE (r
) = r
;
10564 if (TREE_CODE (decl
) != TYPE_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
10565 /* Record this non-type partial instantiation. */
10566 register_specialization (r
, t
,
10567 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
10572 case FUNCTION_DECL
:
10575 tree argvec
= NULL_TREE
;
10583 /* Nobody should be tsubst'ing into non-template functions. */
10584 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
10586 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
10591 /* If T is not dependent, just return it. We have to
10592 increment PROCESSING_TEMPLATE_DECL because
10593 value_dependent_expression_p assumes that nothing is
10594 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10595 ++processing_template_decl
;
10596 dependent_p
= value_dependent_expression_p (t
);
10597 --processing_template_decl
;
10601 /* Calculate the most general template of which R is a
10602 specialization, and the complete set of arguments used to
10604 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
10605 argvec
= tsubst_template_args (DECL_TI_ARGS
10606 (DECL_TEMPLATE_RESULT
10607 (DECL_TI_TEMPLATE (t
))),
10608 args
, complain
, in_decl
);
10609 if (argvec
== error_mark_node
)
10610 RETURN (error_mark_node
);
10612 /* Check to see if we already have this specialization. */
10613 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
10614 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
10622 /* We can see more levels of arguments than parameters if
10623 there was a specialization of a member template, like
10626 template <class T> struct S { template <class U> void f(); }
10627 template <> template <class U> void S<int>::f(U);
10629 Here, we'll be substituting into the specialization,
10630 because that's where we can find the code we actually
10631 want to generate, but we'll have enough arguments for
10632 the most general template.
10634 We also deal with the peculiar case:
10636 template <class T> struct S {
10637 template <class U> friend void f();
10639 template <class U> void f() {}
10641 template void f<double>();
10643 Here, the ARGS for the instantiation of will be {int,
10644 double}. But, we only need as many ARGS as there are
10645 levels of template parameters in CODE_PATTERN. We are
10646 careful not to get fooled into reducing the ARGS in
10649 template <class T> struct S { template <class U> void f(U); }
10650 template <class T> template <> void S<T>::f(int) {}
10652 which we can spot because the pattern will be a
10653 specialization in this case. */
10654 args_depth
= TMPL_ARGS_DEPTH (args
);
10656 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
10657 if (args_depth
> parms_depth
10658 && !DECL_TEMPLATE_SPECIALIZATION (t
))
10659 args
= get_innermost_template_args (args
, parms_depth
);
10663 /* This special case arises when we have something like this:
10665 template <class T> struct S {
10666 friend void f<int>(int, double);
10669 Here, the DECL_TI_TEMPLATE for the friend declaration
10670 will be an IDENTIFIER_NODE. We are being called from
10671 tsubst_friend_function, and we want only to create a
10672 new decl (R) with appropriate types so that we can call
10673 determine_specialization. */
10674 gen_tmpl
= NULL_TREE
;
10677 if (DECL_CLASS_SCOPE_P (t
))
10679 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
10683 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
10684 complain
, t
, /*entering_scope=*/1);
10689 ctx
= DECL_CONTEXT (t
);
10691 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10692 if (type
== error_mark_node
)
10693 RETURN (error_mark_node
);
10695 /* If we hit excessive deduction depth, the type is bogus even if
10696 it isn't error_mark_node, so don't build a decl. */
10697 if (excessive_deduction_depth
)
10698 RETURN (error_mark_node
);
10700 /* We do NOT check for matching decls pushed separately at this
10701 point, as they may not represent instantiations of this
10702 template, and in any case are considered separate under the
10705 DECL_USE_TEMPLATE (r
) = 0;
10706 TREE_TYPE (r
) = type
;
10707 /* Clear out the mangled name and RTL for the instantiation. */
10708 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
10709 SET_DECL_RTL (r
, NULL
);
10710 /* Leave DECL_INITIAL set on deleted instantiations. */
10711 if (!DECL_DELETED_FN (r
))
10712 DECL_INITIAL (r
) = NULL_TREE
;
10713 DECL_CONTEXT (r
) = ctx
;
10715 /* OpenMP UDRs have the only argument a reference to the declared
10716 type. We want to diagnose if the declared type is a reference,
10717 which is invalid, but as references to references are usually
10718 quietly merged, diagnose it here. */
10719 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
10722 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
10723 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
10724 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
10725 error_at (DECL_SOURCE_LOCATION (t
),
10726 "reference type %qT in "
10727 "%<#pragma omp declare reduction%>", argtype
);
10728 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
10729 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
10733 if (member
&& DECL_CONV_FN_P (r
))
10734 /* Type-conversion operator. Reconstruct the name, in
10735 case it's the name of one of the template's parameters. */
10736 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
10738 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
10740 DECL_RESULT (r
) = NULL_TREE
;
10742 TREE_STATIC (r
) = 0;
10743 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
10744 DECL_EXTERNAL (r
) = 1;
10745 /* If this is an instantiation of a function with internal
10746 linkage, we already know what object file linkage will be
10747 assigned to the instantiation. */
10748 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
10749 DECL_DEFER_OUTPUT (r
) = 0;
10750 DECL_CHAIN (r
) = NULL_TREE
;
10751 DECL_PENDING_INLINE_INFO (r
) = 0;
10752 DECL_PENDING_INLINE_P (r
) = 0;
10753 DECL_SAVED_TREE (r
) = NULL_TREE
;
10754 DECL_STRUCT_FUNCTION (r
) = NULL
;
10756 /* We'll re-clone as appropriate in instantiate_template. */
10757 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
10759 /* If we aren't complaining now, return on error before we register
10760 the specialization so that we'll complain eventually. */
10761 if ((complain
& tf_error
) == 0
10762 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10763 && !grok_op_properties (r
, /*complain=*/false))
10764 RETURN (error_mark_node
);
10766 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10767 this in the special friend case mentioned above where
10768 GEN_TMPL is NULL. */
10771 DECL_TEMPLATE_INFO (r
)
10772 = build_template_info (gen_tmpl
, argvec
);
10773 SET_DECL_IMPLICIT_INSTANTIATION (r
);
10776 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
10778 /* We instantiated this while substituting into
10779 the type earlier (template/friend54.C). */
10782 /* We're not supposed to instantiate default arguments
10783 until they are called, for a template. But, for a
10786 template <class T> void f ()
10787 { extern void g(int i = T()); }
10789 we should do the substitution when the template is
10790 instantiated. We handle the member function case in
10791 instantiate_class_template since the default arguments
10792 might refer to other members of the class. */
10794 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
10795 && !uses_template_parms (argvec
))
10796 tsubst_default_arguments (r
, complain
);
10799 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
10801 /* Copy the list of befriending classes. */
10802 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
10804 friends
= &TREE_CHAIN (*friends
))
10806 *friends
= copy_node (*friends
);
10807 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
10812 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
10814 maybe_retrofit_in_chrg (r
);
10815 if (DECL_CONSTRUCTOR_P (r
))
10816 grok_ctor_properties (ctx
, r
);
10817 if (DECL_INHERITED_CTOR_BASE (r
))
10818 deduce_inheriting_ctor (r
);
10819 /* If this is an instantiation of a member template, clone it.
10820 If it isn't, that'll be handled by
10821 clone_constructors_and_destructors. */
10822 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
10823 clone_function_decl (r
, /*update_method_vec_p=*/0);
10825 else if ((complain
& tf_error
) != 0
10826 && IDENTIFIER_OPNAME_P (DECL_NAME (r
))
10827 && !grok_op_properties (r
, /*complain=*/true))
10828 RETURN (error_mark_node
);
10830 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
10831 SET_DECL_FRIEND_CONTEXT (r
,
10832 tsubst (DECL_FRIEND_CONTEXT (t
),
10833 args
, complain
, in_decl
));
10835 /* Possibly limit visibility based on template args. */
10836 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
10837 if (DECL_VISIBILITY_SPECIFIED (t
))
10839 DECL_VISIBILITY_SPECIFIED (r
) = 0;
10840 DECL_ATTRIBUTES (r
)
10841 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
10843 determine_visibility (r
);
10844 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
10845 && !processing_template_decl
)
10846 defaulted_late_check (r
);
10848 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10849 args
, complain
, in_decl
);
10855 tree type
= NULL_TREE
;
10857 tree expanded_types
= NULL_TREE
;
10858 tree prev_r
= NULL_TREE
;
10859 tree first_r
= NULL_TREE
;
10861 if (DECL_PACK_P (t
))
10863 /* If there is a local specialization that isn't a
10864 parameter pack, it means that we're doing a "simple"
10865 substitution from inside tsubst_pack_expansion. Just
10866 return the local specialization (which will be a single
10868 tree spec
= retrieve_local_specialization (t
);
10870 && TREE_CODE (spec
) == PARM_DECL
10871 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
10874 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10875 the parameters in this function parameter pack. */
10876 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10877 complain
, in_decl
);
10878 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10880 len
= TREE_VEC_LENGTH (expanded_types
);
10882 /* Zero-length parameter packs are boring. Just substitute
10885 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
10890 /* All we did was update the type. Make a note of that. */
10891 type
= expanded_types
;
10892 expanded_types
= NULL_TREE
;
10896 /* Loop through all of the parameters we'll build. When T is
10897 a function parameter pack, LEN is the number of expanded
10898 types in EXPANDED_TYPES; otherwise, LEN is 1. */
10900 for (i
= 0; i
< len
; ++i
)
10904 if (DECL_TEMPLATE_PARM_P (t
))
10905 SET_DECL_TEMPLATE_PARM_P (r
);
10907 if (expanded_types
)
10908 /* We're on the Ith parameter of the function parameter
10911 /* Get the Ith type. */
10912 type
= TREE_VEC_ELT (expanded_types
, i
);
10914 /* Rename the parameter to include the index. */
10916 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
10919 /* We're dealing with a normal parameter. */
10920 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10922 type
= type_decays_to (type
);
10923 TREE_TYPE (r
) = type
;
10924 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
10926 if (DECL_INITIAL (r
))
10928 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
10929 DECL_INITIAL (r
) = TREE_TYPE (r
);
10931 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
10932 complain
, in_decl
);
10935 DECL_CONTEXT (r
) = NULL_TREE
;
10937 if (!DECL_TEMPLATE_PARM_P (r
))
10938 DECL_ARG_TYPE (r
) = type_passed_as (type
);
10940 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
10941 args
, complain
, in_decl
);
10943 /* Keep track of the first new parameter we
10944 generate. That's what will be returned to the
10949 /* Build a proper chain of parameters when substituting
10950 into a function parameter pack. */
10952 DECL_CHAIN (prev_r
) = r
;
10955 /* If cp_unevaluated_operand is set, we're just looking for a
10956 single dummy parameter, so don't keep going. */
10957 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
10958 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
10959 complain
, DECL_CHAIN (t
));
10961 /* FIRST_R contains the start of the chain we've built. */
10968 tree type
= NULL_TREE
;
10969 tree vec
= NULL_TREE
;
10970 tree expanded_types
= NULL_TREE
;
10973 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
10975 /* This field is a lambda capture pack. Return a TREE_VEC of
10976 the expanded fields to instantiate_class_template_1 and
10977 store them in the specializations hash table as a
10978 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
10979 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
10980 complain
, in_decl
);
10981 if (TREE_CODE (expanded_types
) == TREE_VEC
)
10983 len
= TREE_VEC_LENGTH (expanded_types
);
10984 vec
= make_tree_vec (len
);
10988 /* All we did was update the type. Make a note of that. */
10989 type
= expanded_types
;
10990 expanded_types
= NULL_TREE
;
10994 for (int i
= 0; i
< len
; ++i
)
10997 if (expanded_types
)
10999 type
= TREE_VEC_ELT (expanded_types
, i
);
11001 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
11004 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11006 if (type
== error_mark_node
)
11007 RETURN (error_mark_node
);
11008 TREE_TYPE (r
) = type
;
11009 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11011 if (DECL_C_BIT_FIELD (r
))
11012 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11013 non-bit-fields DECL_INITIAL is a non-static data member
11014 initializer, which gets deferred instantiation. */
11016 = tsubst_expr (DECL_INITIAL (t
), args
,
11018 /*integral_constant_expression_p=*/true);
11019 else if (DECL_INITIAL (t
))
11021 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11022 NSDMI in perform_member_init. Still set DECL_INITIAL
11023 so that we know there is one. */
11024 DECL_INITIAL (r
) = void_node
;
11025 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
11026 retrofit_lang_decl (r
);
11027 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
11029 /* We don't have to set DECL_CONTEXT here; it is set by
11030 finish_member_declaration. */
11031 DECL_CHAIN (r
) = NULL_TREE
;
11033 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
11034 args
, complain
, in_decl
);
11037 TREE_VEC_ELT (vec
, i
) = r
;
11043 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11044 tree tpack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11045 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11046 SET_ARGUMENT_PACK_ARGS (tpack
, expanded_types
);
11047 TREE_TYPE (pack
) = tpack
;
11048 register_specialization (pack
, t
, args
, false, 0);
11054 /* We reach here only for member using decls. We also need to check
11055 uses_template_parms because DECL_DEPENDENT_P is not set for a
11056 using-declaration that designates a member of the current
11057 instantiation (c++/53549). */
11058 if (DECL_DEPENDENT_P (t
)
11059 || uses_template_parms (USING_DECL_SCOPE (t
)))
11061 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
11062 complain
, in_decl
);
11063 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
11064 r
= do_class_using_decl (inst_scope
, name
);
11066 r
= error_mark_node
;
11069 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
11070 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
11076 DECL_CHAIN (r
) = NULL_TREE
;
11083 tree argvec
= NULL_TREE
;
11084 tree gen_tmpl
= NULL_TREE
;
11086 tree tmpl
= NULL_TREE
;
11088 tree type
= NULL_TREE
;
11091 if (TREE_TYPE (t
) == error_mark_node
)
11092 RETURN (error_mark_node
);
11094 if (TREE_CODE (t
) == TYPE_DECL
11095 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
11097 /* If this is the canonical decl, we don't have to
11098 mess with instantiations, and often we can't (for
11099 typename, template type parms and such). Note that
11100 TYPE_NAME is not correct for the above test if
11101 we've copied the type for a typedef. */
11102 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11103 if (type
== error_mark_node
)
11104 RETURN (error_mark_node
);
11105 r
= TYPE_NAME (type
);
11109 /* Check to see if we already have the specialization we
11112 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
11114 /* T is a static data member or namespace-scope entity.
11115 We have to substitute into namespace-scope variables
11116 (even though such entities are never templates) because
11119 template <class T> void f() { extern T t; }
11121 where the entity referenced is not known until
11122 instantiation time. */
11124 ctx
= DECL_CONTEXT (t
);
11125 if (DECL_CLASS_SCOPE_P (t
))
11127 ctx
= tsubst_aggr_type (ctx
, args
,
11129 in_decl
, /*entering_scope=*/1);
11130 /* If CTX is unchanged, then T is in fact the
11131 specialization we want. That situation occurs when
11132 referencing a static data member within in its own
11133 class. We can use pointer equality, rather than
11134 same_type_p, because DECL_CONTEXT is always
11136 if (ctx
== DECL_CONTEXT (t
)
11137 && (TREE_CODE (t
) != TYPE_DECL
11138 /* ... unless T is a member template; in which
11139 case our caller can be willing to create a
11140 specialization of that template represented
11142 || !(DECL_TI_TEMPLATE (t
)
11143 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))))
11149 tmpl
= DECL_TI_TEMPLATE (t
);
11150 gen_tmpl
= most_general_template (tmpl
);
11151 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
11152 if (argvec
== error_mark_node
)
11153 RETURN (error_mark_node
);
11154 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
11155 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
11160 /* A local variable. */
11162 /* Subsequent calls to pushdecl will fill this in. */
11164 spec
= retrieve_local_specialization (t
);
11166 /* If we already have the specialization we need, there is
11167 nothing more to do. */
11174 /* Create a new node for the specialization we need. */
11176 if (type
== NULL_TREE
)
11178 if (is_typedef_decl (t
))
11179 type
= DECL_ORIGINAL_TYPE (t
);
11181 type
= TREE_TYPE (t
);
11183 && VAR_HAD_UNKNOWN_BOUND (t
)
11184 && type
!= error_mark_node
)
11185 type
= strip_array_domain (type
);
11186 type
= tsubst (type
, args
, complain
, in_decl
);
11190 /* Even if the original location is out of scope, the
11191 newly substituted one is not. */
11192 DECL_DEAD_FOR_LOCAL (r
) = 0;
11193 DECL_INITIALIZED_P (r
) = 0;
11194 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
11195 if (type
== error_mark_node
)
11196 RETURN (error_mark_node
);
11197 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11199 /* It may seem that this case cannot occur, since:
11204 declares a function, not a variable. However:
11207 template <typename T> void g() { T t; }
11208 template void g<f>();
11210 is an attempt to declare a variable with function
11212 error ("variable %qD has function type",
11213 /* R is not yet sufficiently initialized, so we
11214 just use its name. */
11216 RETURN (error_mark_node
);
11218 type
= complete_type (type
);
11219 /* Wait until cp_finish_decl to set this again, to handle
11220 circular dependency (template/instantiate6.C). */
11221 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
11222 type
= check_var_type (DECL_NAME (r
), type
);
11224 if (DECL_HAS_VALUE_EXPR_P (t
))
11226 tree ve
= DECL_VALUE_EXPR (t
);
11227 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
11228 /*constant_expression_p=*/false);
11229 if (REFERENCE_REF_P (ve
))
11231 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
11232 ve
= TREE_OPERAND (ve
, 0);
11234 SET_DECL_VALUE_EXPR (r
, ve
);
11237 else if (DECL_SELF_REFERENCE_P (t
))
11238 SET_DECL_SELF_REFERENCE_P (r
);
11239 TREE_TYPE (r
) = type
;
11240 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
11241 DECL_CONTEXT (r
) = ctx
;
11242 /* Clear out the mangled name and RTL for the instantiation. */
11243 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
11244 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11245 SET_DECL_RTL (r
, NULL
);
11246 /* The initializer must not be expanded until it is required;
11247 see [temp.inst]. */
11248 DECL_INITIAL (r
) = NULL_TREE
;
11249 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
11250 SET_DECL_RTL (r
, NULL
);
11251 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
11254 /* Possibly limit visibility based on template args. */
11255 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
11256 if (DECL_VISIBILITY_SPECIFIED (t
))
11258 DECL_VISIBILITY_SPECIFIED (r
) = 0;
11259 DECL_ATTRIBUTES (r
)
11260 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
11262 determine_visibility (r
);
11267 /* A static data member declaration is always marked
11268 external when it is declared in-class, even if an
11269 initializer is present. We mimic the non-template
11270 processing here. */
11271 DECL_EXTERNAL (r
) = 1;
11273 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
11274 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
11275 SET_DECL_IMPLICIT_INSTANTIATION (r
);
11277 else if (!cp_unevaluated_operand
)
11278 register_local_specialization (r
, t
);
11280 DECL_CHAIN (r
) = NULL_TREE
;
11282 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
11284 args
, complain
, in_decl
);
11286 /* Preserve a typedef that names a type. */
11287 if (is_typedef_decl (r
))
11289 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
11290 set_underlying_type (r
);
11293 layout_decl (r
, 0);
11298 gcc_unreachable ();
11303 /* Restore the file and line information. */
11304 input_location
= saved_loc
;
11309 /* Substitute into the ARG_TYPES of a function type.
11310 If END is a TREE_CHAIN, leave it and any following types
11314 tsubst_arg_types (tree arg_types
,
11317 tsubst_flags_t complain
,
11320 tree remaining_arg_types
;
11321 tree type
= NULL_TREE
;
11323 tree expanded_args
= NULL_TREE
;
11326 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
11329 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
11330 args
, end
, complain
, in_decl
);
11331 if (remaining_arg_types
== error_mark_node
)
11332 return error_mark_node
;
11334 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
11336 /* For a pack expansion, perform substitution on the
11337 entire expression. Later on, we'll handle the arguments
11339 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
11340 args
, complain
, in_decl
);
11342 if (TREE_CODE (expanded_args
) == TREE_VEC
)
11343 /* So that we'll spin through the parameters, one by one. */
11344 i
= TREE_VEC_LENGTH (expanded_args
);
11347 /* We only partially substituted into the parameter
11348 pack. Our type is TYPE_PACK_EXPANSION. */
11349 type
= expanded_args
;
11350 expanded_args
= NULL_TREE
;
11358 type
= TREE_VEC_ELT (expanded_args
, i
);
11360 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
11362 if (type
== error_mark_node
)
11363 return error_mark_node
;
11364 if (VOID_TYPE_P (type
))
11366 if (complain
& tf_error
)
11368 error ("invalid parameter type %qT", type
);
11370 error ("in declaration %q+D", in_decl
);
11372 return error_mark_node
;
11375 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
11376 return error_mark_node
;
11378 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11379 top-level qualifiers as required. */
11380 type
= cv_unqualified (type_decays_to (type
));
11382 /* We do not substitute into default arguments here. The standard
11383 mandates that they be instantiated only when needed, which is
11384 done in build_over_call. */
11385 default_arg
= TREE_PURPOSE (arg_types
);
11387 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
11389 /* We've instantiated a template before its default arguments
11390 have been parsed. This can happen for a nested template
11391 class, and is not an error unless we require the default
11392 argument in a call of this function. */
11393 remaining_arg_types
=
11394 tree_cons (default_arg
, type
, remaining_arg_types
);
11395 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
11398 remaining_arg_types
=
11399 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
11402 return remaining_arg_types
;
11405 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11406 *not* handle the exception-specification for FNTYPE, because the
11407 initial substitution of explicitly provided template parameters
11408 during argument deduction forbids substitution into the
11409 exception-specification:
11413 All references in the function type of the function template to the
11414 corresponding template parameters are replaced by the specified tem-
11415 plate argument values. If a substitution in a template parameter or
11416 in the function type of the function template results in an invalid
11417 type, type deduction fails. [Note: The equivalent substitution in
11418 exception specifications is done only when the function is instanti-
11419 ated, at which point a program is ill-formed if the substitution
11420 results in an invalid type.] */
11423 tsubst_function_type (tree t
,
11425 tsubst_flags_t complain
,
11429 tree arg_types
= NULL_TREE
;
11432 /* The TYPE_CONTEXT is not used for function/method types. */
11433 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
11435 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11437 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
11439 if (late_return_type_p
)
11441 /* Substitute the argument types. */
11442 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11443 complain
, in_decl
);
11444 if (arg_types
== error_mark_node
)
11445 return error_mark_node
;
11447 tree save_ccp
= current_class_ptr
;
11448 tree save_ccr
= current_class_ref
;
11449 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
11450 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
11451 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
11454 /* DR 1207: 'this' is in scope in the trailing return type. */
11455 inject_this_parameter (this_type
, cp_type_quals (this_type
));
11458 /* Substitute the return type. */
11459 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11463 current_class_ptr
= save_ccp
;
11464 current_class_ref
= save_ccr
;
11468 /* Substitute the return type. */
11469 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11471 if (return_type
== error_mark_node
)
11472 return error_mark_node
;
11473 /* DR 486 clarifies that creation of a function type with an
11474 invalid return type is a deduction failure. */
11475 if (TREE_CODE (return_type
) == ARRAY_TYPE
11476 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
11478 if (complain
& tf_error
)
11480 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
11481 error ("function returning an array");
11483 error ("function returning a function");
11485 return error_mark_node
;
11488 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
11489 return error_mark_node
;
11491 if (!late_return_type_p
)
11493 /* Substitute the argument types. */
11494 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
11495 complain
, in_decl
);
11496 if (arg_types
== error_mark_node
)
11497 return error_mark_node
;
11500 /* Construct a new type node and return it. */
11501 if (TREE_CODE (t
) == FUNCTION_TYPE
)
11503 fntype
= build_function_type (return_type
, arg_types
);
11504 fntype
= apply_memfn_quals (fntype
,
11505 type_memfn_quals (t
),
11506 type_memfn_rqual (t
));
11510 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
11511 /* Don't pick up extra function qualifiers from the basetype. */
11512 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
11513 if (! MAYBE_CLASS_TYPE_P (r
))
11517 Type deduction may fail for any of the following
11520 -- Attempting to create "pointer to member of T" when T
11521 is not a class type. */
11522 if (complain
& tf_error
)
11523 error ("creating pointer to member function of non-class type %qT",
11525 return error_mark_node
;
11528 fntype
= build_method_type_directly (r
, return_type
,
11529 TREE_CHAIN (arg_types
));
11530 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
11532 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
11534 if (late_return_type_p
)
11535 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
11540 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11541 ARGS into that specification, and return the substituted
11542 specification. If there is no specification, return NULL_TREE. */
11545 tsubst_exception_specification (tree fntype
,
11547 tsubst_flags_t complain
,
11554 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
11555 new_specs
= NULL_TREE
;
11556 if (specs
&& TREE_PURPOSE (specs
))
11558 /* A noexcept-specifier. */
11559 tree expr
= TREE_PURPOSE (specs
);
11560 if (TREE_CODE (expr
) == INTEGER_CST
)
11564 /* Defer instantiation of noexcept-specifiers to avoid
11565 excessive instantiations (c++/49107). */
11566 new_specs
= make_node (DEFERRED_NOEXCEPT
);
11567 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
11569 /* We already partially instantiated this member template,
11570 so combine the new args with the old. */
11571 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
11572 = DEFERRED_NOEXCEPT_PATTERN (expr
);
11573 DEFERRED_NOEXCEPT_ARGS (new_specs
)
11574 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
11578 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
11579 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
11583 new_specs
= tsubst_copy_and_build
11584 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
11585 /*integral_constant_expression_p=*/true);
11586 new_specs
= build_noexcept_spec (new_specs
, complain
);
11590 if (! TREE_VALUE (specs
))
11597 tree expanded_specs
= NULL_TREE
;
11599 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
11601 /* Expand the pack expansion type. */
11602 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
11606 if (expanded_specs
== error_mark_node
)
11607 return error_mark_node
;
11608 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
11609 len
= TREE_VEC_LENGTH (expanded_specs
);
11612 /* We're substituting into a member template, so
11613 we got a TYPE_PACK_EXPANSION back. Add that
11614 expansion and move on. */
11615 gcc_assert (TREE_CODE (expanded_specs
)
11616 == TYPE_PACK_EXPANSION
);
11617 new_specs
= add_exception_specifier (new_specs
,
11620 specs
= TREE_CHAIN (specs
);
11625 for (i
= 0; i
< len
; ++i
)
11627 if (expanded_specs
)
11628 spec
= TREE_VEC_ELT (expanded_specs
, i
);
11630 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
11631 if (spec
== error_mark_node
)
11633 new_specs
= add_exception_specifier (new_specs
, spec
,
11637 specs
= TREE_CHAIN (specs
);
11643 /* Take the tree structure T and replace template parameters used
11644 therein with the argument vector ARGS. IN_DECL is an associated
11645 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11646 Issue error and warning messages under control of COMPLAIN. Note
11647 that we must be relatively non-tolerant of extensions here, in
11648 order to preserve conformance; if we allow substitutions that
11649 should not be allowed, we may allow argument deductions that should
11650 not succeed, and therefore report ambiguous overload situations
11651 where there are none. In theory, we could allow the substitution,
11652 but indicate that it should have failed, and allow our caller to
11653 make sure that the right thing happens, but we don't try to do this
11656 This function is used for dealing with types, decls and the like;
11657 for expressions, use tsubst_expr or tsubst_copy. */
11660 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11662 enum tree_code code
;
11663 tree type
, r
= NULL_TREE
;
11665 if (t
== NULL_TREE
|| t
== error_mark_node
11666 || t
== integer_type_node
11667 || t
== void_type_node
11668 || t
== char_type_node
11669 || t
== unknown_type_node
11670 || TREE_CODE (t
) == NAMESPACE_DECL
11671 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
11675 return tsubst_decl (t
, args
, complain
);
11677 if (args
== NULL_TREE
)
11680 code
= TREE_CODE (t
);
11682 if (code
== IDENTIFIER_NODE
)
11683 type
= IDENTIFIER_TYPE_VALUE (t
);
11685 type
= TREE_TYPE (t
);
11687 gcc_assert (type
!= unknown_type_node
);
11689 /* Reuse typedefs. We need to do this to handle dependent attributes,
11690 such as attribute aligned. */
11692 && typedef_variant_p (t
))
11694 tree decl
= TYPE_NAME (t
);
11696 if (alias_template_specialization_p (t
))
11698 /* DECL represents an alias template and we want to
11700 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11701 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11702 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
11704 else if (DECL_CLASS_SCOPE_P (decl
)
11705 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11706 && uses_template_parms (DECL_CONTEXT (decl
)))
11708 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
11709 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
11710 r
= retrieve_specialization (tmpl
, gen_args
, 0);
11712 else if (DECL_FUNCTION_SCOPE_P (decl
)
11713 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
11714 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
11715 r
= retrieve_local_specialization (decl
);
11717 /* The typedef is from a non-template context. */
11723 r
= cp_build_qualified_type_real
11724 (r
, cp_type_quals (t
) | cp_type_quals (r
),
11725 complain
| tf_ignore_bad_quals
);
11730 /* We don't have an instantiation yet, so drop the typedef. */
11731 int quals
= cp_type_quals (t
);
11732 t
= DECL_ORIGINAL_TYPE (decl
);
11733 t
= cp_build_qualified_type_real (t
, quals
,
11734 complain
| tf_ignore_bad_quals
);
11739 && code
!= TYPENAME_TYPE
11740 && code
!= TEMPLATE_TYPE_PARM
11741 && code
!= IDENTIFIER_NODE
11742 && code
!= FUNCTION_TYPE
11743 && code
!= METHOD_TYPE
)
11744 type
= tsubst (type
, args
, complain
, in_decl
);
11745 if (type
== error_mark_node
)
11746 return error_mark_node
;
11752 case ENUMERAL_TYPE
:
11753 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
11754 /*entering_scope=*/0);
11757 case IDENTIFIER_NODE
:
11768 if (t
== integer_type_node
)
11771 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
11772 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
11776 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
11778 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
11779 /*integral_constant_expression_p=*/false);
11781 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11783 if (TREE_CODE (max
) == NOP_EXPR
11784 && TREE_SIDE_EFFECTS (omax
)
11785 && !TREE_TYPE (max
))
11786 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
11788 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11789 with TREE_SIDE_EFFECTS that indicates this is not an integral
11790 constant expression. */
11791 if (processing_template_decl
11792 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
11794 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
11795 TREE_SIDE_EFFECTS (max
) = 1;
11798 return compute_array_index_type (NULL_TREE
, max
, complain
);
11801 case TEMPLATE_TYPE_PARM
:
11802 case TEMPLATE_TEMPLATE_PARM
:
11803 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11804 case TEMPLATE_PARM_INDEX
:
11809 tree arg
= NULL_TREE
;
11813 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
11814 template_parm_level_and_index (t
, &level
, &idx
);
11816 levels
= TMPL_ARGS_DEPTH (args
);
11817 if (level
<= levels
)
11819 arg
= TMPL_ARG (args
, level
, idx
);
11821 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
11823 /* See through ARGUMENT_PACK_SELECT arguments. */
11824 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
11825 /* If the selected argument is an expansion E, that most
11826 likely means we were called from
11827 gen_elem_of_pack_expansion_instantiation during the
11828 substituting of pack an argument pack (which Ith
11829 element is a pack expansion, where I is
11830 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11831 In this case, the Ith element resulting from this
11832 substituting is going to be a pack expansion, which
11833 pattern is the pattern of E. Let's return the
11835 gen_elem_of_pack_expansion_instantiation will
11836 build the resulting pack expansion from it. */
11837 if (PACK_EXPANSION_P (arg
))
11838 arg
= PACK_EXPANSION_PATTERN (arg
);
11842 if (arg
== error_mark_node
)
11843 return error_mark_node
;
11844 else if (arg
!= NULL_TREE
)
11846 if (ARGUMENT_PACK_P (arg
))
11847 /* If ARG is an argument pack, we don't actually want to
11848 perform a substitution here, because substitutions
11849 for argument packs are only done
11850 element-by-element. We can get to this point when
11851 substituting the type of a non-type template
11852 parameter pack, when that type actually contains
11853 template parameter packs from an outer template, e.g.,
11855 template<typename... Types> struct A {
11856 template<Types... Values> struct B { };
11860 if (code
== TEMPLATE_TYPE_PARM
)
11863 gcc_assert (TYPE_P (arg
));
11865 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
11867 return cp_build_qualified_type_real
11868 (arg
, quals
, complain
| tf_ignore_bad_quals
);
11870 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11872 /* We are processing a type constructed from a
11873 template template parameter. */
11874 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
11875 args
, complain
, in_decl
);
11876 if (argvec
== error_mark_node
)
11877 return error_mark_node
;
11879 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
11880 || TREE_CODE (arg
) == TEMPLATE_DECL
11881 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
11883 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
11884 /* Consider this code:
11886 template <template <class> class Template>
11888 template <class Arg> using Bind = Template<Arg>;
11891 template <template <class> class Template, class Arg>
11892 using Instantiate = Template<Arg>; //#0
11894 template <template <class> class Template,
11897 Instantiate<Internal<Template>::template Bind,
11900 When #1 is parsed, the
11901 BOUND_TEMPLATE_TEMPLATE_PARM representing the
11902 parameter `Template' in #0 matches the
11903 UNBOUND_CLASS_TEMPLATE representing the argument
11904 `Internal<Template>::template Bind'; We then want
11905 to assemble the type `Bind<Argument>' that can't
11906 be fully created right now, because
11907 `Internal<Template>' not being complete, the Bind
11908 template cannot be looked up in that context. So
11909 we need to "store" `Bind<Argument>' for later
11910 when the context of Bind becomes complete. Let's
11911 store that in a TYPENAME_TYPE. */
11912 return make_typename_type (TYPE_CONTEXT (arg
),
11913 build_nt (TEMPLATE_ID_EXPR
,
11914 TYPE_IDENTIFIER (arg
),
11919 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
11920 are resolving nested-types in the signature of a
11921 member function templates. Otherwise ARG is a
11922 TEMPLATE_DECL and is the real template to be
11924 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11925 arg
= TYPE_NAME (arg
);
11927 r
= lookup_template_class (arg
,
11929 DECL_CONTEXT (arg
),
11930 /*entering_scope=*/0,
11932 return cp_build_qualified_type_real
11933 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
11936 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
11937 return convert_from_reference (unshare_expr (arg
));
11941 /* This can happen during the attempted tsubst'ing in
11942 unify. This means that we don't yet have any information
11943 about the template parameter in question. */
11946 /* Early in template argument deduction substitution, we don't
11947 want to reduce the level of 'auto', or it will be confused
11948 with a normal template parm in subsequent deduction. */
11949 if (is_auto (t
) && (complain
& tf_partial
))
11952 /* If we get here, we must have been looking at a parm for a
11953 more deeply nested template. Make a new version of this
11954 template parameter, but with a lower level. */
11957 case TEMPLATE_TYPE_PARM
:
11958 case TEMPLATE_TEMPLATE_PARM
:
11959 case BOUND_TEMPLATE_TEMPLATE_PARM
:
11960 if (cp_type_quals (t
))
11962 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
11963 r
= cp_build_qualified_type_real
11964 (r
, cp_type_quals (t
),
11965 complain
| (code
== TEMPLATE_TYPE_PARM
11966 ? tf_ignore_bad_quals
: 0));
11971 TEMPLATE_TYPE_PARM_INDEX (r
)
11972 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
11973 r
, levels
, args
, complain
);
11974 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
11975 TYPE_MAIN_VARIANT (r
) = r
;
11976 TYPE_POINTER_TO (r
) = NULL_TREE
;
11977 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
11979 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
11980 /* We have reduced the level of the template
11981 template parameter, but not the levels of its
11982 template parameters, so canonical_type_parameter
11983 will not be able to find the canonical template
11984 template parameter for this level. Thus, we
11985 require structural equality checking to compare
11986 TEMPLATE_TEMPLATE_PARMs. */
11987 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11988 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
11989 SET_TYPE_STRUCTURAL_EQUALITY (r
);
11991 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
11993 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
11995 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
11996 complain
, in_decl
);
11997 if (argvec
== error_mark_node
)
11998 return error_mark_node
;
12000 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
12001 = build_template_info (TYPE_TI_TEMPLATE (t
), argvec
);
12006 case TEMPLATE_PARM_INDEX
:
12007 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
12011 gcc_unreachable ();
12019 tree purpose
, value
, chain
;
12021 if (t
== void_list_node
)
12024 purpose
= TREE_PURPOSE (t
);
12027 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
12028 if (purpose
== error_mark_node
)
12029 return error_mark_node
;
12031 value
= TREE_VALUE (t
);
12034 value
= tsubst (value
, args
, complain
, in_decl
);
12035 if (value
== error_mark_node
)
12036 return error_mark_node
;
12038 chain
= TREE_CHAIN (t
);
12039 if (chain
&& chain
!= void_type_node
)
12041 chain
= tsubst (chain
, args
, complain
, in_decl
);
12042 if (chain
== error_mark_node
)
12043 return error_mark_node
;
12045 if (purpose
== TREE_PURPOSE (t
)
12046 && value
== TREE_VALUE (t
)
12047 && chain
== TREE_CHAIN (t
))
12049 return hash_tree_cons (purpose
, value
, chain
);
12053 /* We should never be tsubsting a binfo. */
12054 gcc_unreachable ();
12057 /* A vector of template arguments. */
12058 gcc_assert (!type
);
12059 return tsubst_template_args (t
, args
, complain
, in_decl
);
12062 case REFERENCE_TYPE
:
12064 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
12069 Type deduction may fail for any of the following
12072 -- Attempting to create a pointer to reference type.
12073 -- Attempting to create a reference to a reference type or
12074 a reference to void.
12076 Core issue 106 says that creating a reference to a reference
12077 during instantiation is no longer a cause for failure. We
12078 only enforce this check in strict C++98 mode. */
12079 if ((TREE_CODE (type
) == REFERENCE_TYPE
12080 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
12081 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
12083 static location_t last_loc
;
12085 /* We keep track of the last time we issued this error
12086 message to avoid spewing a ton of messages during a
12087 single bad template instantiation. */
12088 if (complain
& tf_error
12089 && last_loc
!= input_location
)
12091 if (VOID_TYPE_P (type
))
12092 error ("forming reference to void");
12093 else if (code
== POINTER_TYPE
)
12094 error ("forming pointer to reference type %qT", type
);
12096 error ("forming reference to reference type %qT", type
);
12097 last_loc
= input_location
;
12100 return error_mark_node
;
12102 else if (TREE_CODE (type
) == FUNCTION_TYPE
12103 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
12104 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
12106 if (complain
& tf_error
)
12108 if (code
== POINTER_TYPE
)
12109 error ("forming pointer to qualified function type %qT",
12112 error ("forming reference to qualified function type %qT",
12115 return error_mark_node
;
12117 else if (code
== POINTER_TYPE
)
12119 r
= build_pointer_type (type
);
12120 if (TREE_CODE (type
) == METHOD_TYPE
)
12121 r
= build_ptrmemfunc_type (r
);
12123 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
12124 /* In C++0x, during template argument substitution, when there is an
12125 attempt to create a reference to a reference type, reference
12126 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12128 "If a template-argument for a template-parameter T names a type
12129 that is a reference to a type A, an attempt to create the type
12130 'lvalue reference to cv T' creates the type 'lvalue reference to
12131 A,' while an attempt to create the type type rvalue reference to
12132 cv T' creates the type T"
12134 r
= cp_build_reference_type
12136 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
12138 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
12139 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12141 if (cxx_dialect
>= cxx1y
12142 && !(TREE_CODE (t
) == REFERENCE_TYPE
&& REFERENCE_VLA_OK (t
))
12143 && array_of_runtime_bound_p (type
)
12144 && (flag_iso
|| warn_vla
> 0))
12146 if (complain
& tf_warning_or_error
)
12148 (input_location
, OPT_Wvla
,
12149 code
== REFERENCE_TYPE
12150 ? G_("cannot declare reference to array of runtime bound")
12151 : G_("cannot declare pointer to array of runtime bound"));
12153 r
= error_mark_node
;
12156 if (r
!= error_mark_node
)
12157 /* Will this ever be needed for TYPE_..._TO values? */
12164 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
12165 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
12169 Type deduction may fail for any of the following
12172 -- Attempting to create "pointer to member of T" when T
12173 is not a class type. */
12174 if (complain
& tf_error
)
12175 error ("creating pointer to member of non-class type %qT", r
);
12176 return error_mark_node
;
12178 if (TREE_CODE (type
) == REFERENCE_TYPE
)
12180 if (complain
& tf_error
)
12181 error ("creating pointer to member reference type %qT", type
);
12182 return error_mark_node
;
12184 if (VOID_TYPE_P (type
))
12186 if (complain
& tf_error
)
12187 error ("creating pointer to member of type void");
12188 return error_mark_node
;
12190 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
12191 if (TREE_CODE (type
) == FUNCTION_TYPE
)
12193 /* The type of the implicit object parameter gets its
12194 cv-qualifiers from the FUNCTION_TYPE. */
12197 = build_memfn_type (type
, r
, type_memfn_quals (type
),
12198 type_memfn_rqual (type
));
12199 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
12200 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
12204 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
12208 case FUNCTION_TYPE
:
12213 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
12214 if (fntype
== error_mark_node
)
12215 return error_mark_node
;
12217 /* Substitute the exception specification. */
12218 specs
= tsubst_exception_specification (t
, args
, complain
,
12219 in_decl
, /*defer_ok*/true);
12220 if (specs
== error_mark_node
)
12221 return error_mark_node
;
12223 fntype
= build_exception_variant (fntype
, specs
);
12228 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
12229 if (domain
== error_mark_node
)
12230 return error_mark_node
;
12232 /* As an optimization, we avoid regenerating the array type if
12233 it will obviously be the same as T. */
12234 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
12237 /* These checks should match the ones in create_array_type_for_decl.
12241 The deduction may fail for any of the following reasons:
12243 -- Attempting to create an array with an element type that
12244 is void, a function type, or a reference type, or [DR337]
12245 an abstract class type. */
12246 if (VOID_TYPE_P (type
)
12247 || TREE_CODE (type
) == FUNCTION_TYPE
12248 || (TREE_CODE (type
) == ARRAY_TYPE
12249 && TYPE_DOMAIN (type
) == NULL_TREE
)
12250 || TREE_CODE (type
) == REFERENCE_TYPE
)
12252 if (complain
& tf_error
)
12253 error ("creating array of %qT", type
);
12254 return error_mark_node
;
12257 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
12258 return error_mark_node
;
12260 r
= build_cplus_array_type (type
, domain
);
12262 if (TYPE_USER_ALIGN (t
))
12264 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
12265 TYPE_USER_ALIGN (r
) = 1;
12271 case TYPENAME_TYPE
:
12273 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12274 in_decl
, /*entering_scope=*/1);
12275 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
12276 complain
, in_decl
);
12278 if (ctx
== error_mark_node
|| f
== error_mark_node
)
12279 return error_mark_node
;
12281 if (!MAYBE_CLASS_TYPE_P (ctx
))
12283 if (complain
& tf_error
)
12284 error ("%qT is not a class, struct, or union type", ctx
);
12285 return error_mark_node
;
12287 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
12289 /* Normally, make_typename_type does not require that the CTX
12290 have complete type in order to allow things like:
12292 template <class T> struct S { typename S<T>::X Y; };
12294 But, such constructs have already been resolved by this
12295 point, so here CTX really should have complete type, unless
12296 it's a partial instantiation. */
12297 ctx
= complete_type (ctx
);
12298 if (!COMPLETE_TYPE_P (ctx
))
12300 if (complain
& tf_error
)
12301 cxx_incomplete_type_error (NULL_TREE
, ctx
);
12302 return error_mark_node
;
12306 f
= make_typename_type (ctx
, f
, typename_type
,
12307 complain
| tf_keep_type_decl
);
12308 if (f
== error_mark_node
)
12310 if (TREE_CODE (f
) == TYPE_DECL
)
12312 complain
|= tf_ignore_bad_quals
;
12316 if (TREE_CODE (f
) != TYPENAME_TYPE
)
12318 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
12320 if (complain
& tf_error
)
12321 error ("%qT resolves to %qT, which is not an enumeration type",
12324 return error_mark_node
;
12326 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
12328 if (complain
& tf_error
)
12329 error ("%qT resolves to %qT, which is is not a class type",
12332 return error_mark_node
;
12336 return cp_build_qualified_type_real
12337 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
12340 case UNBOUND_CLASS_TEMPLATE
:
12342 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
12343 in_decl
, /*entering_scope=*/1);
12344 tree name
= TYPE_IDENTIFIER (t
);
12345 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
12347 if (ctx
== error_mark_node
|| name
== error_mark_node
)
12348 return error_mark_node
;
12351 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
12352 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
12359 ++cp_unevaluated_operand
;
12360 ++c_inhibit_evaluation_warnings
;
12362 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
12364 /*integral_constant_expression_p=*/false);
12366 --cp_unevaluated_operand
;
12367 --c_inhibit_evaluation_warnings
;
12369 type
= finish_typeof (type
);
12370 return cp_build_qualified_type_real (type
,
12372 | cp_type_quals (type
),
12376 case DECLTYPE_TYPE
:
12380 ++cp_unevaluated_operand
;
12381 ++c_inhibit_evaluation_warnings
;
12383 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
12384 complain
|tf_decltype
, in_decl
,
12385 /*function_p*/false,
12386 /*integral_constant_expression*/false);
12388 --cp_unevaluated_operand
;
12389 --c_inhibit_evaluation_warnings
;
12391 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
12392 type
= lambda_capture_field_type (type
,
12393 DECLTYPE_FOR_INIT_CAPTURE (t
));
12394 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
12395 type
= lambda_proxy_type (type
);
12398 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
12399 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
12401 /* In a template ~id could be either a complement expression
12402 or an unqualified-id naming a destructor; if instantiating
12403 it produces an expression, it's not an id-expression or
12406 type
= finish_decltype_type (type
, id
, complain
);
12408 return cp_build_qualified_type_real (type
,
12410 | cp_type_quals (type
),
12414 case UNDERLYING_TYPE
:
12416 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
12417 complain
, in_decl
);
12418 return finish_underlying_type (type
);
12421 case TYPE_ARGUMENT_PACK
:
12422 case NONTYPE_ARGUMENT_PACK
:
12424 tree r
= TYPE_P (t
) ? cxx_make_type (code
) : make_node (code
);
12426 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
12430 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
12432 /* For template nontype argument packs, also substitute into
12434 if (code
== NONTYPE_ARGUMENT_PACK
)
12435 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12454 /* We should use one of the expression tsubsts for these codes. */
12455 gcc_unreachable ();
12458 sorry ("use of %qs in template", get_tree_code_name (code
));
12459 return error_mark_node
;
12463 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12464 type of the expression on the left-hand side of the "." or "->"
12468 tsubst_baselink (tree baselink
, tree object_type
,
12469 tree args
, tsubst_flags_t complain
, tree in_decl
)
12472 tree qualifying_scope
;
12475 tree template_args
= 0;
12476 bool template_id_p
= false;
12477 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
12479 /* A baselink indicates a function from a base class. Both the
12480 BASELINK_ACCESS_BINFO and the base class referenced may
12481 indicate bases of the template class, rather than the
12482 instantiated class. In addition, lookups that were not
12483 ambiguous before may be ambiguous now. Therefore, we perform
12484 the lookup again. */
12485 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
12486 qualifying_scope
= tsubst (qualifying_scope
, args
,
12487 complain
, in_decl
);
12488 fns
= BASELINK_FUNCTIONS (baselink
);
12489 optype
= tsubst (BASELINK_OPTYPE (baselink
), args
, complain
, in_decl
);
12490 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
12492 template_id_p
= true;
12493 template_args
= TREE_OPERAND (fns
, 1);
12494 fns
= TREE_OPERAND (fns
, 0);
12496 template_args
= tsubst_template_args (template_args
, args
,
12497 complain
, in_decl
);
12499 name
= DECL_NAME (get_first_fn (fns
));
12500 if (IDENTIFIER_TYPENAME_P (name
))
12501 name
= mangle_conv_op_name_for_type (optype
);
12502 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
12504 return error_mark_node
;
12506 /* If lookup found a single function, mark it as used at this
12507 point. (If it lookup found multiple functions the one selected
12508 later by overload resolution will be marked as used at that
12510 if (BASELINK_P (baselink
))
12511 fns
= BASELINK_FUNCTIONS (baselink
);
12512 if (!template_id_p
&& !really_overloaded_fn (fns
))
12513 mark_used (OVL_CURRENT (fns
));
12515 /* Add back the template arguments, if present. */
12516 if (BASELINK_P (baselink
) && template_id_p
)
12517 BASELINK_FUNCTIONS (baselink
)
12518 = build_nt (TEMPLATE_ID_EXPR
,
12519 BASELINK_FUNCTIONS (baselink
),
12521 /* Update the conversion operator type. */
12522 BASELINK_OPTYPE (baselink
) = optype
;
12525 object_type
= current_class_type
;
12528 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
12534 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12535 true if the qualified-id will be a postfix-expression in-and-of
12536 itself; false if more of the postfix-expression follows the
12537 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12541 tsubst_qualified_id (tree qualified_id
, tree args
,
12542 tsubst_flags_t complain
, tree in_decl
,
12543 bool done
, bool address_p
)
12549 tree template_args
;
12550 location_t loc
= UNKNOWN_LOCATION
;
12552 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
12554 /* Figure out what name to look up. */
12555 name
= TREE_OPERAND (qualified_id
, 1);
12556 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
12558 is_template
= true;
12559 loc
= EXPR_LOCATION (name
);
12560 template_args
= TREE_OPERAND (name
, 1);
12562 template_args
= tsubst_template_args (template_args
, args
,
12563 complain
, in_decl
);
12564 name
= TREE_OPERAND (name
, 0);
12568 is_template
= false;
12569 template_args
= NULL_TREE
;
12572 /* Substitute into the qualifying scope. When there are no ARGS, we
12573 are just trying to simplify a non-dependent expression. In that
12574 case the qualifying scope may be dependent, and, in any case,
12575 substituting will not help. */
12576 scope
= TREE_OPERAND (qualified_id
, 0);
12579 scope
= tsubst (scope
, args
, complain
, in_decl
);
12580 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
12585 if (dependent_scope_p (scope
))
12588 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
12589 return build_qualified_name (NULL_TREE
, scope
, expr
,
12590 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
12593 if (!BASELINK_P (name
) && !DECL_P (expr
))
12595 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
12597 /* A BIT_NOT_EXPR is used to represent a destructor. */
12598 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
12600 error ("qualifying type %qT does not match destructor name ~%qT",
12601 scope
, TREE_OPERAND (expr
, 0));
12602 expr
= error_mark_node
;
12605 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
12606 /*is_type_p=*/0, false);
12609 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
12610 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
12611 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
12613 if (complain
& tf_error
)
12615 error ("dependent-name %qE is parsed as a non-type, but "
12616 "instantiation yields a type", qualified_id
);
12617 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
12619 return error_mark_node
;
12625 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
12627 /* Remember that there was a reference to this entity. */
12631 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
12633 if (complain
& tf_error
)
12634 qualified_name_lookup_error (scope
,
12635 TREE_OPERAND (qualified_id
, 1),
12636 expr
, input_location
);
12637 return error_mark_node
;
12641 expr
= lookup_template_function (expr
, template_args
);
12643 if (expr
== error_mark_node
&& complain
& tf_error
)
12644 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
12645 expr
, input_location
);
12646 else if (TYPE_P (scope
))
12648 expr
= (adjust_result_of_qualified_name_lookup
12649 (expr
, scope
, current_nonlambda_class_type ()));
12650 expr
= (finish_qualified_id_expr
12651 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
12652 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
12653 /*template_arg_p=*/false, complain
));
12656 /* Expressions do not generally have reference type. */
12657 if (TREE_CODE (expr
) != SCOPE_REF
12658 /* However, if we're about to form a pointer-to-member, we just
12659 want the referenced member referenced. */
12660 && TREE_CODE (expr
) != OFFSET_REF
)
12661 expr
= convert_from_reference (expr
);
12666 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12667 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12671 tsubst_init (tree init
, tree decl
, tree args
,
12672 tsubst_flags_t complain
, tree in_decl
)
12677 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
12681 /* If we had an initializer but it
12682 instantiated to nothing,
12683 value-initialize the object. This will
12684 only occur when the initializer was a
12685 pack expansion where the parameter packs
12686 used in that expansion were of length
12688 init
= build_value_init (TREE_TYPE (decl
),
12690 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
12691 init
= get_target_expr_sfinae (init
, complain
);
12697 /* Like tsubst, but deals with expressions. This function just replaces
12698 template parms; to finish processing the resultant expression, use
12699 tsubst_copy_and_build or tsubst_expr. */
12702 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
12704 enum tree_code code
;
12707 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
12710 code
= TREE_CODE (t
);
12715 r
= retrieve_local_specialization (t
);
12717 if (r
== NULL_TREE
)
12719 /* We get here for a use of 'this' in an NSDMI. */
12720 if (DECL_NAME (t
) == this_identifier
12721 && current_function_decl
12722 && DECL_CONSTRUCTOR_P (current_function_decl
))
12723 return current_class_ptr
;
12725 /* This can happen for a parameter name used later in a function
12726 declaration (such as in a late-specified return type). Just
12727 make a dummy decl, since it's only used for its type. */
12728 gcc_assert (cp_unevaluated_operand
!= 0);
12729 r
= tsubst_decl (t
, args
, complain
);
12730 /* Give it the template pattern as its context; its true context
12731 hasn't been instantiated yet and this is good enough for
12733 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
12736 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12737 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12746 if (DECL_TEMPLATE_PARM_P (t
))
12747 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
12748 /* There is no need to substitute into namespace-scope
12750 if (DECL_NAMESPACE_SCOPE_P (t
))
12752 /* If ARGS is NULL, then T is known to be non-dependent. */
12753 if (args
== NULL_TREE
)
12754 return integral_constant_value (t
);
12756 /* Unfortunately, we cannot just call lookup_name here.
12759 template <int I> int f() {
12761 struct S { void g() { E e = a; } };
12764 When we instantiate f<7>::S::g(), say, lookup_name is not
12765 clever enough to find f<7>::a. */
12767 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12768 /*entering_scope=*/0);
12770 for (v
= TYPE_VALUES (enum_type
);
12772 v
= TREE_CHAIN (v
))
12773 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
12774 return TREE_VALUE (v
);
12776 /* We didn't find the name. That should never happen; if
12777 name-lookup found it during preliminary parsing, we
12778 should find it again here during instantiation. */
12779 gcc_unreachable ();
12784 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12786 /* Check for a local specialization set up by
12787 tsubst_pack_expansion. */
12788 if (tree r
= retrieve_local_specialization (t
))
12790 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
12791 r
= ARGUMENT_PACK_SELECT_ARG (r
);
12795 /* When retrieving a capture pack from a generic lambda, remove the
12796 lambda call op's own template argument list from ARGS. Only the
12797 template arguments active for the closure type should be used to
12798 retrieve the pack specialization. */
12799 if (LAMBDA_FUNCTION_P (current_function_decl
)
12800 && (template_class_depth (DECL_CONTEXT (t
))
12801 != TMPL_ARGS_DEPTH (args
)))
12802 args
= strip_innermost_template_args (args
, 1);
12804 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12805 tsubst_decl put in the hash table. */
12806 return retrieve_specialization (t
, args
, 0);
12809 if (DECL_CONTEXT (t
))
12813 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
12814 /*entering_scope=*/1);
12815 if (ctx
!= DECL_CONTEXT (t
))
12817 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
12820 if (complain
& tf_error
)
12821 error ("using invalid field %qD", t
);
12822 return error_mark_node
;
12831 case FUNCTION_DECL
:
12832 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
12833 r
= tsubst (t
, args
, complain
, in_decl
);
12834 else if (local_variable_p (t
))
12836 r
= retrieve_local_specialization (t
);
12837 if (r
== NULL_TREE
)
12839 /* First try name lookup to find the instantiation. */
12840 r
= lookup_name (DECL_NAME (t
));
12843 /* Make sure that the one we found is the one we want. */
12844 tree ctx
= tsubst (DECL_CONTEXT (t
), args
,
12845 complain
, in_decl
);
12846 if (ctx
!= DECL_CONTEXT (r
))
12854 /* This can happen for a variable used in a
12855 late-specified return type of a local lambda, or for a
12856 local static or constant. Building a new VAR_DECL
12857 should be OK in all those cases. */
12858 r
= tsubst_decl (t
, args
, complain
);
12859 if (decl_maybe_constant_var_p (r
))
12861 /* We can't call cp_finish_decl, so handle the
12862 initializer by hand. */
12863 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
12864 complain
, in_decl
);
12865 if (!processing_template_decl
)
12866 init
= maybe_constant_init (init
);
12867 if (processing_template_decl
12868 ? potential_constant_expression (init
)
12869 : reduced_constant_expression_p (init
))
12870 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
12871 = TREE_CONSTANT (r
) = true;
12872 DECL_INITIAL (r
) = init
;
12874 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
12875 || decl_constant_var_p (r
)
12876 || errorcount
|| sorrycount
);
12877 if (!processing_template_decl
)
12879 if (TREE_STATIC (r
))
12880 rest_of_decl_compilation (r
, toplevel_bindings_p (),
12882 else if (decl_constant_var_p (r
))
12883 /* A use of a local constant decays to its value.
12884 FIXME update for core DR 696. */
12885 r
= integral_constant_value (r
);
12888 /* Remember this for subsequent uses. */
12889 if (local_specializations
)
12890 register_local_specialization (r
, t
);
12898 case NAMESPACE_DECL
:
12902 /* An OVERLOAD will always be a non-dependent overload set; an
12903 overload set from function scope will just be represented with an
12904 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12905 gcc_assert (!uses_template_parms (t
));
12909 return tsubst_baselink (t
, current_nonlambda_class_type (),
12910 args
, complain
, in_decl
);
12912 case TEMPLATE_DECL
:
12913 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12914 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
12915 args
, complain
, in_decl
);
12916 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
12917 return tsubst (t
, args
, complain
, in_decl
);
12918 else if (DECL_CLASS_SCOPE_P (t
)
12919 && uses_template_parms (DECL_CONTEXT (t
)))
12921 /* Template template argument like the following example need
12924 template <template <class> class TT> struct C {};
12925 template <class T> struct D {
12926 template <class U> struct E {};
12931 We are processing the template argument `E' in #1 for
12932 the template instantiation #2. Originally, `E' is a
12933 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
12934 have to substitute this with one having context `D<int>'. */
12936 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
12937 return lookup_field (context
, DECL_NAME(t
), 0, false);
12940 /* Ordinary template template argument. */
12944 case REINTERPRET_CAST_EXPR
:
12945 case CONST_CAST_EXPR
:
12946 case STATIC_CAST_EXPR
:
12947 case DYNAMIC_CAST_EXPR
:
12948 case IMPLICIT_CONV_EXPR
:
12952 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12953 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
12954 return build1 (code
, type
, op0
);
12958 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
12961 tree expanded
, op
= TREE_OPERAND (t
, 0);
12964 if (SIZEOF_EXPR_TYPE_P (t
))
12965 op
= TREE_TYPE (op
);
12967 ++cp_unevaluated_operand
;
12968 ++c_inhibit_evaluation_warnings
;
12969 /* We only want to compute the number of arguments. */
12970 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
12971 --cp_unevaluated_operand
;
12972 --c_inhibit_evaluation_warnings
;
12974 if (TREE_CODE (expanded
) == TREE_VEC
)
12975 len
= TREE_VEC_LENGTH (expanded
);
12977 if (expanded
== error_mark_node
)
12978 return error_mark_node
;
12979 else if (PACK_EXPANSION_P (expanded
)
12980 || (TREE_CODE (expanded
) == TREE_VEC
12982 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
12984 if (TREE_CODE (expanded
) == TREE_VEC
)
12985 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
12987 if (TYPE_P (expanded
))
12988 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
12989 complain
& tf_error
);
12991 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
12992 complain
& tf_error
);
12995 return build_int_cst (size_type_node
, len
);
12997 if (SIZEOF_EXPR_TYPE_P (t
))
12999 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
13000 args
, complain
, in_decl
);
13001 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
13002 r
= build1 (SIZEOF_EXPR
,
13003 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
13004 SIZEOF_EXPR_TYPE_P (r
) = 1;
13011 case TRUTH_NOT_EXPR
:
13014 case UNARY_PLUS_EXPR
: /* Unary + */
13016 case AT_ENCODE_EXPR
:
13020 case REALPART_EXPR
:
13021 case IMAGPART_EXPR
:
13024 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13025 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13026 return build1 (code
, type
, op0
);
13029 case COMPONENT_REF
:
13034 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13035 name
= TREE_OPERAND (t
, 1);
13036 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
13038 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13039 complain
, in_decl
);
13040 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13042 else if (TREE_CODE (name
) == SCOPE_REF
13043 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
13045 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13046 complain
, in_decl
);
13047 name
= TREE_OPERAND (name
, 1);
13048 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
13049 complain
, in_decl
);
13050 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
13051 name
= build_qualified_name (/*type=*/NULL_TREE
,
13053 /*template_p=*/false);
13055 else if (BASELINK_P (name
))
13056 name
= tsubst_baselink (name
,
13057 non_reference (TREE_TYPE (object
)),
13061 name
= tsubst_copy (name
, args
, complain
, in_decl
);
13062 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
13068 case TRUNC_DIV_EXPR
:
13069 case CEIL_DIV_EXPR
:
13070 case FLOOR_DIV_EXPR
:
13071 case ROUND_DIV_EXPR
:
13072 case EXACT_DIV_EXPR
:
13076 case TRUNC_MOD_EXPR
:
13077 case FLOOR_MOD_EXPR
:
13078 case TRUTH_ANDIF_EXPR
:
13079 case TRUTH_ORIF_EXPR
:
13080 case TRUTH_AND_EXPR
:
13081 case TRUTH_OR_EXPR
:
13094 case COMPOUND_EXPR
:
13097 case PREDECREMENT_EXPR
:
13098 case PREINCREMENT_EXPR
:
13099 case POSTDECREMENT_EXPR
:
13100 case POSTINCREMENT_EXPR
:
13102 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13103 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13104 return build_nt (code
, op0
, op1
);
13109 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13110 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13111 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
13112 QUALIFIED_NAME_IS_TEMPLATE (t
));
13117 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13118 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13119 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
13124 int n
= VL_EXP_OPERAND_LENGTH (t
);
13125 tree result
= build_vl_exp (CALL_EXPR
, n
);
13127 for (i
= 0; i
< n
; i
++)
13128 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
13129 complain
, in_decl
);
13135 case PSEUDO_DTOR_EXPR
:
13136 case VEC_PERM_EXPR
:
13138 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13139 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13140 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13141 r
= build_nt (code
, op0
, op1
, op2
);
13142 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
13148 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13149 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13150 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
13151 r
= build_nt (code
, op0
, op1
, op2
);
13152 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
13158 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13159 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13160 r
= build_nt (code
, op0
, op1
);
13161 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
13162 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
13166 case TEMPLATE_ID_EXPR
:
13168 /* Substituted template arguments */
13169 tree fn
= TREE_OPERAND (t
, 0);
13170 tree targs
= TREE_OPERAND (t
, 1);
13172 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
13174 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
13176 return lookup_template_function (fn
, targs
);
13181 tree purpose
, value
, chain
;
13183 if (t
== void_list_node
)
13186 purpose
= TREE_PURPOSE (t
);
13188 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
13189 value
= TREE_VALUE (t
);
13191 value
= tsubst_copy (value
, args
, complain
, in_decl
);
13192 chain
= TREE_CHAIN (t
);
13193 if (chain
&& chain
!= void_type_node
)
13194 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
13195 if (purpose
== TREE_PURPOSE (t
)
13196 && value
== TREE_VALUE (t
)
13197 && chain
== TREE_CHAIN (t
))
13199 return tree_cons (purpose
, value
, chain
);
13204 case ENUMERAL_TYPE
:
13206 case TEMPLATE_TYPE_PARM
:
13207 case TEMPLATE_TEMPLATE_PARM
:
13208 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13209 case TEMPLATE_PARM_INDEX
:
13211 case REFERENCE_TYPE
:
13213 case FUNCTION_TYPE
:
13216 case TYPENAME_TYPE
:
13217 case UNBOUND_CLASS_TEMPLATE
:
13219 case DECLTYPE_TYPE
:
13221 return tsubst (t
, args
, complain
, in_decl
);
13225 /* Fall through. */
13226 case IDENTIFIER_NODE
:
13227 if (IDENTIFIER_TYPENAME_P (t
))
13229 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13230 return mangle_conv_op_name_for_type (new_type
);
13236 /* This is handled by tsubst_copy_and_build. */
13237 gcc_unreachable ();
13241 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13242 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13243 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
13246 case CLEANUP_POINT_EXPR
:
13247 /* We shouldn't have built any of these during initial template
13248 generation. Instead, they should be built during instantiation
13249 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13250 gcc_unreachable ();
13254 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13255 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
13256 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
13257 r
= build2 (code
, type
, op0
, op1
);
13258 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
13259 mark_used (TREE_OPERAND (r
, 1));
13263 case EXPR_PACK_EXPANSION
:
13264 error ("invalid use of pack expansion expression");
13265 return error_mark_node
;
13267 case NONTYPE_ARGUMENT_PACK
:
13268 error ("use %<...%> to expand argument pack");
13269 return error_mark_node
;
13272 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
13280 /* Instantiate any typedefs in the type. */
13281 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13282 r
= fold_convert (type
, t
);
13283 gcc_assert (TREE_CODE (r
) == code
);
13288 /* These can sometimes show up in a partial instantiation, but never
13289 involve template parms. */
13290 gcc_assert (!uses_template_parms (t
));
13294 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13295 gcc_checking_assert (false);
13300 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13303 tsubst_omp_clauses (tree clauses
, bool declare_simd
,
13304 tree args
, tsubst_flags_t complain
, tree in_decl
)
13306 tree new_clauses
= NULL
, nc
, oc
;
13308 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
13310 nc
= copy_node (oc
);
13311 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
13314 switch (OMP_CLAUSE_CODE (nc
))
13316 case OMP_CLAUSE_LASTPRIVATE
:
13317 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
13319 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
13320 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
13321 in_decl
, /*integral_constant_expression_p=*/false);
13322 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
13323 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
13326 case OMP_CLAUSE_PRIVATE
:
13327 case OMP_CLAUSE_SHARED
:
13328 case OMP_CLAUSE_FIRSTPRIVATE
:
13329 case OMP_CLAUSE_COPYIN
:
13330 case OMP_CLAUSE_COPYPRIVATE
:
13331 case OMP_CLAUSE_IF
:
13332 case OMP_CLAUSE_NUM_THREADS
:
13333 case OMP_CLAUSE_SCHEDULE
:
13334 case OMP_CLAUSE_COLLAPSE
:
13335 case OMP_CLAUSE_FINAL
:
13336 case OMP_CLAUSE_DEPEND
:
13337 case OMP_CLAUSE_FROM
:
13338 case OMP_CLAUSE_TO
:
13339 case OMP_CLAUSE_UNIFORM
:
13340 case OMP_CLAUSE_MAP
:
13341 case OMP_CLAUSE_DEVICE
:
13342 case OMP_CLAUSE_DIST_SCHEDULE
:
13343 case OMP_CLAUSE_NUM_TEAMS
:
13344 case OMP_CLAUSE_THREAD_LIMIT
:
13345 case OMP_CLAUSE_SAFELEN
:
13346 case OMP_CLAUSE_SIMDLEN
:
13347 OMP_CLAUSE_OPERAND (nc
, 0)
13348 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13349 in_decl
, /*integral_constant_expression_p=*/false);
13351 case OMP_CLAUSE_REDUCTION
:
13352 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
13354 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
13355 if (TREE_CODE (placeholder
) == SCOPE_REF
)
13357 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
13358 complain
, in_decl
);
13359 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
13360 = build_qualified_name (NULL_TREE
, scope
,
13361 TREE_OPERAND (placeholder
, 1),
13365 gcc_assert (identifier_p (placeholder
));
13367 OMP_CLAUSE_OPERAND (nc
, 0)
13368 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13369 in_decl
, /*integral_constant_expression_p=*/false);
13371 case OMP_CLAUSE_LINEAR
:
13372 case OMP_CLAUSE_ALIGNED
:
13373 OMP_CLAUSE_OPERAND (nc
, 0)
13374 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
13375 in_decl
, /*integral_constant_expression_p=*/false);
13376 OMP_CLAUSE_OPERAND (nc
, 1)
13377 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
13378 in_decl
, /*integral_constant_expression_p=*/false);
13381 case OMP_CLAUSE_NOWAIT
:
13382 case OMP_CLAUSE_ORDERED
:
13383 case OMP_CLAUSE_DEFAULT
:
13384 case OMP_CLAUSE_UNTIED
:
13385 case OMP_CLAUSE_MERGEABLE
:
13386 case OMP_CLAUSE_INBRANCH
:
13387 case OMP_CLAUSE_NOTINBRANCH
:
13388 case OMP_CLAUSE_PROC_BIND
:
13389 case OMP_CLAUSE_FOR
:
13390 case OMP_CLAUSE_PARALLEL
:
13391 case OMP_CLAUSE_SECTIONS
:
13392 case OMP_CLAUSE_TASKGROUP
:
13395 gcc_unreachable ();
13399 new_clauses
= nreverse (new_clauses
);
13401 new_clauses
= finish_omp_clauses (new_clauses
);
13402 return new_clauses
;
13405 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13408 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
13411 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13413 tree purpose
, value
, chain
;
13418 if (TREE_CODE (t
) != TREE_LIST
)
13419 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
13420 /*function_p=*/false,
13421 /*integral_constant_expression_p=*/false);
13423 if (t
== void_list_node
)
13426 purpose
= TREE_PURPOSE (t
);
13428 purpose
= RECUR (purpose
);
13429 value
= TREE_VALUE (t
);
13432 if (TREE_CODE (value
) != LABEL_DECL
)
13433 value
= RECUR (value
);
13436 value
= lookup_label (DECL_NAME (value
));
13437 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
13438 TREE_USED (value
) = 1;
13441 chain
= TREE_CHAIN (t
);
13442 if (chain
&& chain
!= void_type_node
)
13443 chain
= RECUR (chain
);
13444 return tree_cons (purpose
, value
, chain
);
13448 /* Substitute one OMP_FOR iterator. */
13451 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree initv
,
13452 tree condv
, tree incrv
, tree
*clauses
,
13453 tree args
, tsubst_flags_t complain
, tree in_decl
,
13454 bool integral_constant_expression_p
)
13456 #define RECUR(NODE) \
13457 tsubst_expr ((NODE), args, complain, in_decl, \
13458 integral_constant_expression_p)
13459 tree decl
, init
, cond
, incr
;
13461 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
13462 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
13463 decl
= TREE_OPERAND (init
, 0);
13464 init
= TREE_OPERAND (init
, 1);
13465 tree decl_expr
= NULL_TREE
;
13466 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
13468 /* We need to jump through some hoops to handle declarations in the
13469 for-init-statement, since we might need to handle auto deduction,
13470 but we need to keep control of initialization. */
13472 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
13473 decl
= tsubst_decl (decl
, args
, complain
);
13476 decl
= RECUR (decl
);
13477 init
= RECUR (init
);
13479 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
13480 if (auto_node
&& init
)
13482 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
13484 gcc_assert (!type_dependent_expression_p (decl
));
13486 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
13490 /* Declare the variable, but don't let that initialize it. */
13491 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
13492 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
13494 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
13497 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
13498 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13499 if (TREE_CODE (incr
) == MODIFY_EXPR
)
13501 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13502 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
13503 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
13504 NOP_EXPR
, rhs
, complain
);
13507 incr
= RECUR (incr
);
13508 TREE_VEC_ELT (declv
, i
) = decl
;
13509 TREE_VEC_ELT (initv
, i
) = init
;
13510 TREE_VEC_ELT (condv
, i
) = cond
;
13511 TREE_VEC_ELT (incrv
, i
) = incr
;
13517 /* Declare and initialize the variable. */
13524 for (c
= *clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13526 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13527 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
13528 && OMP_CLAUSE_DECL (c
) == decl
)
13530 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
13531 && OMP_CLAUSE_DECL (c
) == decl
)
13532 error ("iteration variable %qD should not be firstprivate", decl
);
13533 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
13534 && OMP_CLAUSE_DECL (c
) == decl
)
13535 error ("iteration variable %qD should not be reduction", decl
);
13539 c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
13540 OMP_CLAUSE_DECL (c
) = decl
;
13541 c
= finish_omp_clauses (c
);
13544 OMP_CLAUSE_CHAIN (c
) = *clauses
;
13549 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
13550 if (COMPARISON_CLASS_P (cond
))
13552 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
13553 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
13554 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
13557 cond
= RECUR (cond
);
13558 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
13559 switch (TREE_CODE (incr
))
13561 case PREINCREMENT_EXPR
:
13562 case PREDECREMENT_EXPR
:
13563 case POSTINCREMENT_EXPR
:
13564 case POSTDECREMENT_EXPR
:
13565 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
13566 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
13569 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13570 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13572 tree rhs
= TREE_OPERAND (incr
, 1);
13573 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13574 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
13575 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
13576 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13577 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
13581 incr
= RECUR (incr
);
13584 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
13585 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
13587 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
13588 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
13589 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
13590 TREE_TYPE (decl
), lhs
,
13591 RECUR (TREE_OPERAND (incr
, 2))));
13593 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
13594 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
13595 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
13597 tree rhs
= TREE_OPERAND (incr
, 2);
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 incr
= RECUR (incr
);
13613 TREE_VEC_ELT (declv
, i
) = decl
;
13614 TREE_VEC_ELT (initv
, i
) = init
;
13615 TREE_VEC_ELT (condv
, i
) = cond
;
13616 TREE_VEC_ELT (incrv
, i
) = incr
;
13620 /* Like tsubst_copy for expressions, etc. but also does semantic
13624 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
13625 bool integral_constant_expression_p
)
13627 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13628 #define RECUR(NODE) \
13629 tsubst_expr ((NODE), args, complain, in_decl, \
13630 integral_constant_expression_p)
13636 if (t
== NULL_TREE
|| t
== error_mark_node
)
13639 loc
= input_location
;
13640 if (EXPR_HAS_LOCATION (t
))
13641 input_location
= EXPR_LOCATION (t
);
13642 if (STATEMENT_CODE_P (TREE_CODE (t
)))
13643 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
13645 switch (TREE_CODE (t
))
13647 case STATEMENT_LIST
:
13649 tree_stmt_iterator i
;
13650 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
13651 RECUR (tsi_stmt (i
));
13655 case CTOR_INITIALIZER
:
13656 finish_mem_initializers (tsubst_initializer_list
13657 (TREE_OPERAND (t
, 0), args
));
13661 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
13665 tmp
= RECUR (EXPR_STMT_EXPR (t
));
13666 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
13667 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
13669 finish_expr_stmt (tmp
);
13673 do_using_directive (USING_STMT_NAMESPACE (t
));
13678 tree decl
, pattern_decl
;
13681 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
13682 if (TREE_CODE (decl
) == LABEL_DECL
)
13683 finish_label_decl (DECL_NAME (decl
));
13684 else if (TREE_CODE (decl
) == USING_DECL
)
13686 tree scope
= USING_DECL_SCOPE (decl
);
13687 tree name
= DECL_NAME (decl
);
13690 scope
= tsubst (scope
, args
, complain
, in_decl
);
13691 decl
= lookup_qualified_name (scope
, name
,
13692 /*is_type_p=*/false,
13693 /*complain=*/false);
13694 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
13695 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
13697 do_local_using_decl (decl
, scope
, name
);
13699 else if (DECL_PACK_P (decl
))
13701 /* Don't build up decls for a variadic capture proxy, we'll
13702 instantiate the elements directly as needed. */
13707 init
= DECL_INITIAL (decl
);
13708 decl
= tsubst (decl
, args
, complain
, in_decl
);
13709 if (decl
!= error_mark_node
)
13711 /* By marking the declaration as instantiated, we avoid
13712 trying to instantiate it. Since instantiate_decl can't
13713 handle local variables, and since we've already done
13714 all that needs to be done, that's the right thing to
13717 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13719 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
13720 /* Anonymous aggregates are a special case. */
13721 finish_anon_union (decl
);
13722 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
13724 DECL_CONTEXT (decl
) = current_function_decl
;
13725 if (DECL_NAME (decl
) == this_identifier
)
13727 tree lam
= DECL_CONTEXT (current_function_decl
);
13728 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
13729 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
13731 insert_capture_proxy (decl
);
13733 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
13734 /* We already did a pushtag. */;
13735 else if (TREE_CODE (decl
) == FUNCTION_DECL
13736 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
13737 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
13739 DECL_CONTEXT (decl
) = NULL_TREE
;
13741 DECL_CONTEXT (decl
) = current_function_decl
;
13742 cp_check_omp_declare_reduction (decl
);
13746 int const_init
= false;
13747 maybe_push_decl (decl
);
13749 && DECL_PRETTY_FUNCTION_P (decl
))
13751 /* For __PRETTY_FUNCTION__ we have to adjust the
13753 const char *const name
13754 = cxx_printable_name (current_function_decl
, 2);
13755 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
13758 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
13761 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13763 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
13772 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13773 RECUR (FOR_INIT_STMT (t
));
13774 finish_for_init_stmt (stmt
);
13775 tmp
= RECUR (FOR_COND (t
));
13776 finish_for_cond (tmp
, stmt
, false);
13777 tmp
= RECUR (FOR_EXPR (t
));
13778 finish_for_expr (tmp
, stmt
);
13779 RECUR (FOR_BODY (t
));
13780 finish_for_stmt (stmt
);
13783 case RANGE_FOR_STMT
:
13786 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
13787 decl
= RANGE_FOR_DECL (t
);
13788 decl
= tsubst (decl
, args
, complain
, in_decl
);
13789 maybe_push_decl (decl
);
13790 expr
= RECUR (RANGE_FOR_EXPR (t
));
13791 stmt
= cp_convert_range_for (stmt
, decl
, expr
, RANGE_FOR_IVDEP (t
));
13792 RECUR (RANGE_FOR_BODY (t
));
13793 finish_for_stmt (stmt
);
13798 stmt
= begin_while_stmt ();
13799 tmp
= RECUR (WHILE_COND (t
));
13800 finish_while_stmt_cond (tmp
, stmt
, false);
13801 RECUR (WHILE_BODY (t
));
13802 finish_while_stmt (stmt
);
13806 stmt
= begin_do_stmt ();
13807 RECUR (DO_BODY (t
));
13808 finish_do_body (stmt
);
13809 tmp
= RECUR (DO_COND (t
));
13810 finish_do_stmt (tmp
, stmt
, false);
13814 stmt
= begin_if_stmt ();
13815 tmp
= RECUR (IF_COND (t
));
13816 finish_if_stmt_cond (tmp
, stmt
);
13817 RECUR (THEN_CLAUSE (t
));
13818 finish_then_clause (stmt
);
13820 if (ELSE_CLAUSE (t
))
13822 begin_else_clause (stmt
);
13823 RECUR (ELSE_CLAUSE (t
));
13824 finish_else_clause (stmt
);
13827 finish_if_stmt (stmt
);
13831 if (BIND_EXPR_BODY_BLOCK (t
))
13832 stmt
= begin_function_body ();
13834 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
13835 ? BCS_TRY_BLOCK
: 0);
13837 RECUR (BIND_EXPR_BODY (t
));
13839 if (BIND_EXPR_BODY_BLOCK (t
))
13840 finish_function_body (stmt
);
13842 finish_compound_stmt (stmt
);
13846 finish_break_stmt ();
13849 case CONTINUE_STMT
:
13850 finish_continue_stmt ();
13854 stmt
= begin_switch_stmt ();
13855 tmp
= RECUR (SWITCH_STMT_COND (t
));
13856 finish_switch_cond (tmp
, stmt
);
13857 RECUR (SWITCH_STMT_BODY (t
));
13858 finish_switch_stmt (stmt
);
13861 case CASE_LABEL_EXPR
:
13863 tree low
= RECUR (CASE_LOW (t
));
13864 tree high
= RECUR (CASE_HIGH (t
));
13865 finish_case_label (EXPR_LOCATION (t
), low
, high
);
13871 tree decl
= LABEL_EXPR_LABEL (t
);
13874 label
= finish_label_stmt (DECL_NAME (decl
));
13875 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
13876 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
13881 tmp
= GOTO_DESTINATION (t
);
13882 if (TREE_CODE (tmp
) != LABEL_DECL
)
13883 /* Computed goto's must be tsubst'd into. On the other hand,
13884 non-computed gotos must not be; the identifier in question
13885 will have no binding. */
13888 tmp
= DECL_NAME (tmp
);
13889 finish_goto_stmt (tmp
);
13894 tree string
= RECUR (ASM_STRING (t
));
13895 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
13896 complain
, in_decl
);
13897 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
13898 complain
, in_decl
);
13899 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
13900 complain
, in_decl
);
13901 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
13902 complain
, in_decl
);
13903 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
13905 tree asm_expr
= tmp
;
13906 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
13907 asm_expr
= TREE_OPERAND (asm_expr
, 0);
13908 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
13915 stmt
= begin_try_block ();
13916 RECUR (TRY_STMTS (t
));
13917 finish_cleanup_try_block (stmt
);
13918 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
13922 tree compound_stmt
= NULL_TREE
;
13924 if (FN_TRY_BLOCK_P (t
))
13925 stmt
= begin_function_try_block (&compound_stmt
);
13927 stmt
= begin_try_block ();
13929 RECUR (TRY_STMTS (t
));
13931 if (FN_TRY_BLOCK_P (t
))
13932 finish_function_try_block (stmt
);
13934 finish_try_block (stmt
);
13936 RECUR (TRY_HANDLERS (t
));
13937 if (FN_TRY_BLOCK_P (t
))
13938 finish_function_handler_sequence (stmt
, compound_stmt
);
13940 finish_handler_sequence (stmt
);
13946 tree decl
= HANDLER_PARMS (t
);
13950 decl
= tsubst (decl
, args
, complain
, in_decl
);
13951 /* Prevent instantiate_decl from trying to instantiate
13952 this variable. We've already done all that needs to be
13954 if (decl
!= error_mark_node
)
13955 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
13957 stmt
= begin_handler ();
13958 finish_handler_parms (decl
, stmt
);
13959 RECUR (HANDLER_BODY (t
));
13960 finish_handler (stmt
);
13965 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
13966 if (CLASS_TYPE_P (tmp
))
13968 /* Local classes are not independent templates; they are
13969 instantiated along with their containing function. And this
13970 way we don't have to deal with pushing out of one local class
13971 to instantiate a member of another local class. */
13973 /* Closures are handled by the LAMBDA_EXPR. */
13974 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
13975 complete_type (tmp
);
13976 for (fn
= TYPE_METHODS (tmp
); fn
; fn
= DECL_CHAIN (fn
))
13977 if (!DECL_ARTIFICIAL (fn
))
13978 instantiate_decl (fn
, /*defer_ok*/0, /*expl_inst_class*/false);
13982 case STATIC_ASSERT
:
13986 ++c_inhibit_evaluation_warnings
;
13988 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
13991 /*integral_constant_expression_p=*/true);
13992 --c_inhibit_evaluation_warnings
;
13994 finish_static_assert (condition
,
13995 STATIC_ASSERT_MESSAGE (t
),
13996 STATIC_ASSERT_SOURCE_LOCATION (t
),
13997 /*member_p=*/false);
14002 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), false,
14003 args
, complain
, in_decl
);
14004 stmt
= begin_omp_parallel ();
14005 RECUR (OMP_PARALLEL_BODY (t
));
14006 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
14007 = OMP_PARALLEL_COMBINED (t
);
14011 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), false,
14012 args
, complain
, in_decl
);
14013 stmt
= begin_omp_task ();
14014 RECUR (OMP_TASK_BODY (t
));
14015 finish_omp_task (tmp
, stmt
);
14021 case OMP_DISTRIBUTE
:
14023 tree clauses
, body
, pre_body
;
14024 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
14025 tree incrv
= NULL_TREE
;
14028 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), false,
14029 args
, complain
, in_decl
);
14030 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14032 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14033 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14034 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14035 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
14038 stmt
= begin_omp_structured_block ();
14040 pre_body
= push_stmt_list ();
14041 RECUR (OMP_FOR_PRE_BODY (t
));
14042 pre_body
= pop_stmt_list (pre_body
);
14044 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14045 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
14046 tsubst_omp_for_iterator (t
, i
, declv
, initv
, condv
, incrv
,
14047 &clauses
, args
, complain
, in_decl
,
14048 integral_constant_expression_p
);
14050 body
= push_stmt_list ();
14051 RECUR (OMP_FOR_BODY (t
));
14052 body
= pop_stmt_list (body
);
14054 if (OMP_FOR_INIT (t
) != NULL_TREE
)
14055 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
, initv
,
14056 condv
, incrv
, body
, pre_body
, clauses
);
14059 t
= make_node (TREE_CODE (t
));
14060 TREE_TYPE (t
) = void_type_node
;
14061 OMP_FOR_BODY (t
) = body
;
14062 OMP_FOR_PRE_BODY (t
) = pre_body
;
14063 OMP_FOR_CLAUSES (t
) = clauses
;
14064 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
14068 add_stmt (finish_omp_structured_block (stmt
));
14075 case OMP_TARGET_DATA
:
14077 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), false,
14078 args
, complain
, in_decl
);
14079 stmt
= push_stmt_list ();
14080 RECUR (OMP_BODY (t
));
14081 stmt
= pop_stmt_list (stmt
);
14084 OMP_BODY (t
) = stmt
;
14085 OMP_CLAUSES (t
) = tmp
;
14089 case OMP_TARGET_UPDATE
:
14090 tmp
= tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t
), false,
14091 args
, complain
, in_decl
);
14093 OMP_CLAUSES (t
) = tmp
;
14100 case OMP_TASKGROUP
:
14102 stmt
= push_stmt_list ();
14103 RECUR (OMP_BODY (t
));
14104 stmt
= pop_stmt_list (stmt
);
14107 OMP_BODY (t
) = stmt
;
14112 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
14113 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
14115 tree op1
= TREE_OPERAND (t
, 1);
14116 tree rhs1
= NULL_TREE
;
14118 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
14120 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
14121 op1
= TREE_OPERAND (op1
, 1);
14123 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14124 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14125 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
14126 NULL_TREE
, NULL_TREE
, rhs1
,
14127 OMP_ATOMIC_SEQ_CST (t
));
14131 tree op1
= TREE_OPERAND (t
, 1);
14132 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
14133 tree rhs1
= NULL_TREE
;
14134 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
14135 enum tree_code opcode
= NOP_EXPR
;
14136 if (code
== OMP_ATOMIC_READ
)
14138 v
= RECUR (TREE_OPERAND (op1
, 0));
14139 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14141 else if (code
== OMP_ATOMIC_CAPTURE_OLD
14142 || code
== OMP_ATOMIC_CAPTURE_NEW
)
14144 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
14145 v
= RECUR (TREE_OPERAND (op1
, 0));
14146 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
14147 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
14149 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
14150 op11
= TREE_OPERAND (op11
, 1);
14152 lhs
= RECUR (TREE_OPERAND (op11
, 0));
14153 rhs
= RECUR (TREE_OPERAND (op11
, 1));
14154 opcode
= TREE_CODE (op11
);
14155 if (opcode
== MODIFY_EXPR
)
14161 lhs
= RECUR (TREE_OPERAND (op1
, 0));
14162 rhs
= RECUR (TREE_OPERAND (op1
, 1));
14164 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
14165 OMP_ATOMIC_SEQ_CST (t
));
14169 case TRANSACTION_EXPR
:
14172 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
14173 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
14175 if (TRANSACTION_EXPR_IS_STMT (t
))
14177 tree body
= TRANSACTION_EXPR_BODY (t
);
14178 tree noex
= NULL_TREE
;
14179 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
14181 noex
= MUST_NOT_THROW_COND (body
);
14182 if (noex
== NULL_TREE
)
14183 noex
= boolean_true_node
;
14184 body
= TREE_OPERAND (body
, 0);
14186 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
14188 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
14192 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
14193 RECUR (TRANSACTION_EXPR_BODY (t
)),
14200 case MUST_NOT_THROW_EXPR
:
14202 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14203 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
14204 RETURN (build_must_not_throw_expr (op0
, cond
));
14207 case EXPR_PACK_EXPANSION
:
14208 error ("invalid use of pack expansion expression");
14209 RETURN (error_mark_node
);
14211 case NONTYPE_ARGUMENT_PACK
:
14212 error ("use %<...%> to expand argument pack");
14213 RETURN (error_mark_node
);
14215 case CILK_SPAWN_STMT
:
14216 cfun
->calls_cilk_spawn
= 1;
14217 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
14219 case CILK_SYNC_STMT
:
14220 RETURN (build_cilk_sync ());
14222 case COMPOUND_EXPR
:
14223 tmp
= RECUR (TREE_OPERAND (t
, 0));
14224 if (tmp
== NULL_TREE
)
14225 /* If the first operand was a statement, we're done with it. */
14226 RETURN (RECUR (TREE_OPERAND (t
, 1)));
14227 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
14228 RECUR (TREE_OPERAND (t
, 1)),
14231 case ANNOTATE_EXPR
:
14232 tmp
= RECUR (TREE_OPERAND (t
, 0));
14233 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
14234 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
14237 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
14239 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14240 /*function_p=*/false,
14241 integral_constant_expression_p
));
14244 RETURN (NULL_TREE
);
14246 input_location
= loc
;
14252 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14253 function. For description of the body see comment above
14254 cp_parser_omp_declare_reduction_exprs. */
14257 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14259 if (t
== NULL_TREE
|| t
== error_mark_node
)
14262 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
14264 tree_stmt_iterator tsi
;
14267 memset (stmts
, 0, sizeof stmts
);
14268 for (i
= 0, tsi
= tsi_start (t
);
14269 i
< 7 && !tsi_end_p (tsi
);
14270 i
++, tsi_next (&tsi
))
14271 stmts
[i
] = tsi_stmt (tsi
);
14272 gcc_assert (tsi_end_p (tsi
));
14276 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
14277 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
14278 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
14279 args
, complain
, in_decl
);
14280 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
14281 args
, complain
, in_decl
);
14282 DECL_CONTEXT (omp_out
) = current_function_decl
;
14283 DECL_CONTEXT (omp_in
) = current_function_decl
;
14284 keep_next_level (true);
14285 tree block
= begin_omp_structured_block ();
14286 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
14287 block
= finish_omp_structured_block (block
);
14288 block
= maybe_cleanup_point_expr_void (block
);
14289 add_decl_expr (omp_out
);
14290 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
14291 TREE_NO_WARNING (omp_out
) = 1;
14292 add_decl_expr (omp_in
);
14293 finish_expr_stmt (block
);
14297 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
14298 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
14299 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
14300 args
, complain
, in_decl
);
14301 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
14302 args
, complain
, in_decl
);
14303 DECL_CONTEXT (omp_priv
) = current_function_decl
;
14304 DECL_CONTEXT (omp_orig
) = current_function_decl
;
14305 keep_next_level (true);
14306 tree block
= begin_omp_structured_block ();
14307 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
14308 block
= finish_omp_structured_block (block
);
14309 block
= maybe_cleanup_point_expr_void (block
);
14310 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
14311 add_decl_expr (omp_priv
);
14312 add_decl_expr (omp_orig
);
14313 finish_expr_stmt (block
);
14315 add_decl_expr (omp_orig
);
14319 /* T is a postfix-expression that is not being used in a function
14320 call. Return the substituted version of T. */
14323 tsubst_non_call_postfix_expression (tree t
, tree args
,
14324 tsubst_flags_t complain
,
14327 if (TREE_CODE (t
) == SCOPE_REF
)
14328 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
14329 /*done=*/false, /*address_p=*/false);
14331 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
14332 /*function_p=*/false,
14333 /*integral_constant_expression_p=*/false);
14338 /* Sentinel to disable certain warnings during template substitution. */
14340 struct warning_sentinel
{
14343 warning_sentinel(int& flag
, bool suppress
=true)
14344 : flag(flag
), val(flag
) { if (suppress
) flag
= 0; }
14345 ~warning_sentinel() { flag
= val
; }
14348 /* Like tsubst but deals with expressions and performs semantic
14349 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14352 tsubst_copy_and_build (tree t
,
14354 tsubst_flags_t complain
,
14357 bool integral_constant_expression_p
)
14359 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14360 #define RECUR(NODE) \
14361 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14362 /*function_p=*/false, \
14363 integral_constant_expression_p)
14368 if (t
== NULL_TREE
|| t
== error_mark_node
)
14371 loc
= input_location
;
14372 if (EXPR_HAS_LOCATION (t
))
14373 input_location
= EXPR_LOCATION (t
);
14375 /* N3276 decltype magic only applies to calls at the top level or on the
14376 right side of a comma. */
14377 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
14378 complain
&= ~tf_decltype
;
14380 switch (TREE_CODE (t
))
14384 /* Fall through. */
14385 case IDENTIFIER_NODE
:
14389 bool non_integral_constant_expression_p
;
14390 const char *error_msg
;
14392 if (IDENTIFIER_TYPENAME_P (t
))
14394 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14395 t
= mangle_conv_op_name_for_type (new_type
);
14398 /* Look up the name. */
14399 decl
= lookup_name (t
);
14401 /* By convention, expressions use ERROR_MARK_NODE to indicate
14402 failure, not NULL_TREE. */
14403 if (decl
== NULL_TREE
)
14404 decl
= error_mark_node
;
14406 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
14408 integral_constant_expression_p
,
14409 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
14410 &non_integral_constant_expression_p
,
14411 /*template_p=*/false,
14413 /*address_p=*/false,
14414 /*template_arg_p=*/false,
14419 if (!function_p
&& identifier_p (decl
))
14421 if (complain
& tf_error
)
14422 unqualified_name_lookup_error (decl
);
14423 decl
= error_mark_node
;
14428 case TEMPLATE_ID_EXPR
:
14431 tree templ
= RECUR (TREE_OPERAND (t
, 0));
14432 tree targs
= TREE_OPERAND (t
, 1);
14435 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
14437 if (TREE_CODE (templ
) == COMPONENT_REF
)
14439 object
= TREE_OPERAND (templ
, 0);
14440 templ
= TREE_OPERAND (templ
, 1);
14443 object
= NULL_TREE
;
14444 templ
= lookup_template_function (templ
, targs
);
14447 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
14448 object
, templ
, NULL_TREE
));
14450 RETURN (baselink_for_fns (templ
));
14455 tree r
= RECUR (TREE_OPERAND (t
, 0));
14457 if (REFERENCE_REF_P (t
))
14459 /* A type conversion to reference type will be enclosed in
14460 such an indirect ref, but the substitution of the cast
14461 will have also added such an indirect ref. */
14462 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
14463 r
= convert_from_reference (r
);
14466 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
14467 complain
|decltype_flag
);
14473 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14474 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14475 RETURN (build_nop (type
, op0
));
14478 case IMPLICIT_CONV_EXPR
:
14480 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14481 tree expr
= RECUR (TREE_OPERAND (t
, 0));
14482 int flags
= LOOKUP_IMPLICIT
;
14483 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
14484 flags
= LOOKUP_NORMAL
;
14485 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
14491 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14492 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14493 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
14497 case REINTERPRET_CAST_EXPR
:
14498 case CONST_CAST_EXPR
:
14499 case DYNAMIC_CAST_EXPR
:
14500 case STATIC_CAST_EXPR
:
14503 tree op
, r
= NULL_TREE
;
14505 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14506 if (integral_constant_expression_p
14507 && !cast_valid_in_integral_constant_expression_p (type
))
14509 if (complain
& tf_error
)
14510 error ("a cast to a type other than an integral or "
14511 "enumeration type cannot appear in a constant-expression");
14512 RETURN (error_mark_node
);
14515 op
= RECUR (TREE_OPERAND (t
, 0));
14517 warning_sentinel
s(warn_useless_cast
);
14518 switch (TREE_CODE (t
))
14521 r
= build_functional_cast (type
, op
, complain
);
14523 case REINTERPRET_CAST_EXPR
:
14524 r
= build_reinterpret_cast (type
, op
, complain
);
14526 case CONST_CAST_EXPR
:
14527 r
= build_const_cast (type
, op
, complain
);
14529 case DYNAMIC_CAST_EXPR
:
14530 r
= build_dynamic_cast (type
, op
, complain
);
14532 case STATIC_CAST_EXPR
:
14533 r
= build_static_cast (type
, op
, complain
);
14536 gcc_unreachable ();
14542 case POSTDECREMENT_EXPR
:
14543 case POSTINCREMENT_EXPR
:
14544 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14545 args
, complain
, in_decl
);
14546 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
14547 complain
|decltype_flag
));
14549 case PREDECREMENT_EXPR
:
14550 case PREINCREMENT_EXPR
:
14554 case TRUTH_NOT_EXPR
:
14555 case UNARY_PLUS_EXPR
: /* Unary + */
14556 case REALPART_EXPR
:
14557 case IMAGPART_EXPR
:
14558 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
14559 RECUR (TREE_OPERAND (t
, 0)),
14560 complain
|decltype_flag
));
14562 case FIX_TRUNC_EXPR
:
14563 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
14567 op1
= TREE_OPERAND (t
, 0);
14568 if (TREE_CODE (op1
) == LABEL_DECL
)
14569 RETURN (finish_label_address_expr (DECL_NAME (op1
),
14570 EXPR_LOCATION (op1
)));
14571 if (TREE_CODE (op1
) == SCOPE_REF
)
14572 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
14573 /*done=*/true, /*address_p=*/true);
14575 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
14577 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
14578 complain
|decltype_flag
));
14583 case TRUNC_DIV_EXPR
:
14584 case CEIL_DIV_EXPR
:
14585 case FLOOR_DIV_EXPR
:
14586 case ROUND_DIV_EXPR
:
14587 case EXACT_DIV_EXPR
:
14591 case TRUNC_MOD_EXPR
:
14592 case FLOOR_MOD_EXPR
:
14593 case TRUTH_ANDIF_EXPR
:
14594 case TRUTH_ORIF_EXPR
:
14595 case TRUTH_AND_EXPR
:
14596 case TRUTH_OR_EXPR
:
14612 warning_sentinel
s1(warn_type_limits
);
14613 warning_sentinel
s2(warn_div_by_zero
);
14614 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14615 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14616 tree r
= build_x_binary_op
14617 (input_location
, TREE_CODE (t
),
14619 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
14621 : TREE_CODE (TREE_OPERAND (t
, 0))),
14623 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
14625 : TREE_CODE (TREE_OPERAND (t
, 1))),
14627 complain
|decltype_flag
);
14628 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
14629 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14634 case POINTER_PLUS_EXPR
:
14636 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14637 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14638 return fold_build_pointer_plus (op0
, op1
);
14642 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
14643 /*address_p=*/false));
14645 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14646 args
, complain
, in_decl
);
14647 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
14648 RECUR (TREE_OPERAND (t
, 1)),
14649 complain
|decltype_flag
));
14651 case ARRAY_NOTATION_REF
:
14653 tree start_index
, length
, stride
;
14654 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
14655 args
, complain
, in_decl
);
14656 start_index
= RECUR (ARRAY_NOTATION_START (t
));
14657 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
14658 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
14659 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
14660 length
, stride
, TREE_TYPE (op1
)));
14663 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
14664 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
14671 op1
= TREE_OPERAND (t
, 0);
14672 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
14673 op1
= TREE_TYPE (op1
);
14676 /* When there are no ARGS, we are trying to evaluate a
14677 non-dependent expression from the parser. Trying to do
14678 the substitutions may not work. */
14680 op1
= TREE_TYPE (op1
);
14684 ++cp_unevaluated_operand
;
14685 ++c_inhibit_evaluation_warnings
;
14687 op1
= tsubst (op1
, args
, complain
, in_decl
);
14689 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14690 /*function_p=*/false,
14691 /*integral_constant_expression_p=*/
14693 --cp_unevaluated_operand
;
14694 --c_inhibit_evaluation_warnings
;
14697 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
14698 complain
& tf_error
);
14700 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
14701 complain
& tf_error
);
14702 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
14704 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
14706 if (!processing_template_decl
&& TYPE_P (op1
))
14708 r
= build_min (SIZEOF_EXPR
, size_type_node
,
14709 build1 (NOP_EXPR
, op1
, error_mark_node
));
14710 SIZEOF_EXPR_TYPE_P (r
) = 1;
14713 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
14714 TREE_SIDE_EFFECTS (r
) = 0;
14715 TREE_READONLY (r
) = 1;
14717 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
14722 case AT_ENCODE_EXPR
:
14724 op1
= TREE_OPERAND (t
, 0);
14725 ++cp_unevaluated_operand
;
14726 ++c_inhibit_evaluation_warnings
;
14727 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14728 /*function_p=*/false,
14729 /*integral_constant_expression_p=*/false);
14730 --cp_unevaluated_operand
;
14731 --c_inhibit_evaluation_warnings
;
14732 RETURN (objc_build_encode_expr (op1
));
14735 case NOEXCEPT_EXPR
:
14736 op1
= TREE_OPERAND (t
, 0);
14737 ++cp_unevaluated_operand
;
14738 ++c_inhibit_evaluation_warnings
;
14739 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
14740 /*function_p=*/false,
14741 /*integral_constant_expression_p=*/false);
14742 --cp_unevaluated_operand
;
14743 --c_inhibit_evaluation_warnings
;
14744 RETURN (finish_noexcept_expr (op1
, complain
));
14748 warning_sentinel
s(warn_div_by_zero
);
14749 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
14750 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
14751 tree r
= build_x_modify_expr
14752 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
14753 complain
|decltype_flag
);
14754 /* TREE_NO_WARNING must be set if either the expression was
14755 parenthesized or it uses an operator such as >>= rather
14756 than plain assignment. In the former case, it was already
14757 set and must be copied. In the latter case,
14758 build_x_modify_expr sets it and it must not be reset
14760 if (TREE_NO_WARNING (t
))
14761 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
14767 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
14768 args
, complain
, in_decl
);
14769 /* Remember that there was a reference to this entity. */
14772 RETURN (build_x_arrow (input_location
, op1
, complain
));
14776 tree placement
= RECUR (TREE_OPERAND (t
, 0));
14777 tree init
= RECUR (TREE_OPERAND (t
, 3));
14778 vec
<tree
, va_gc
> *placement_vec
;
14779 vec
<tree
, va_gc
> *init_vec
;
14782 if (placement
== NULL_TREE
)
14783 placement_vec
= NULL
;
14786 placement_vec
= make_tree_vector ();
14787 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
14788 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
14791 /* If there was an initializer in the original tree, but it
14792 instantiated to an empty list, then we should pass a
14793 non-NULL empty vector to tell build_new that it was an
14794 empty initializer() rather than no initializer. This can
14795 only happen when the initializer is a pack expansion whose
14796 parameter packs are of length zero. */
14797 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
14801 init_vec
= make_tree_vector ();
14802 if (init
== void_node
)
14803 gcc_assert (init_vec
!= NULL
);
14806 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
14807 vec_safe_push (init_vec
, TREE_VALUE (init
));
14811 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
14812 tree op2
= RECUR (TREE_OPERAND (t
, 2));
14813 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
14814 NEW_EXPR_USE_GLOBAL (t
),
14817 if (placement_vec
!= NULL
)
14818 release_tree_vector (placement_vec
);
14819 if (init_vec
!= NULL
)
14820 release_tree_vector (init_vec
);
14827 tree op0
= RECUR (TREE_OPERAND (t
, 0));
14828 tree op1
= RECUR (TREE_OPERAND (t
, 1));
14829 RETURN (delete_sanity (op0
, op1
,
14830 DELETE_EXPR_USE_VEC (t
),
14831 DELETE_EXPR_USE_GLOBAL (t
),
14835 case COMPOUND_EXPR
:
14837 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
14838 complain
& ~tf_decltype
, in_decl
,
14839 /*function_p=*/false,
14840 integral_constant_expression_p
);
14841 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
14843 RECUR (TREE_OPERAND (t
, 1)),
14844 complain
|decltype_flag
));
14850 vec
<tree
, va_gc
> *call_args
;
14851 unsigned int nargs
, i
;
14856 function
= CALL_EXPR_FN (t
);
14857 /* When we parsed the expression, we determined whether or
14858 not Koenig lookup should be performed. */
14859 koenig_p
= KOENIG_LOOKUP_P (t
);
14860 if (TREE_CODE (function
) == SCOPE_REF
)
14862 qualified_p
= true;
14863 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
14865 /*address_p=*/false);
14867 else if (koenig_p
&& identifier_p (function
))
14869 /* Do nothing; calling tsubst_copy_and_build on an identifier
14870 would incorrectly perform unqualified lookup again.
14872 Note that we can also have an IDENTIFIER_NODE if the earlier
14873 unqualified lookup found a member function; in that case
14874 koenig_p will be false and we do want to do the lookup
14875 again to find the instantiated member function.
14877 FIXME but doing that causes c++/15272, so we need to stop
14878 using IDENTIFIER_NODE in that situation. */
14879 qualified_p
= false;
14883 if (TREE_CODE (function
) == COMPONENT_REF
)
14885 tree op
= TREE_OPERAND (function
, 1);
14887 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
14888 || (BASELINK_P (op
)
14889 && BASELINK_QUALIFIED_P (op
)));
14892 qualified_p
= false;
14894 if (TREE_CODE (function
) == ADDR_EXPR
14895 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
14896 /* Avoid error about taking the address of a constructor. */
14897 function
= TREE_OPERAND (function
, 0);
14899 function
= tsubst_copy_and_build (function
, args
, complain
,
14902 integral_constant_expression_p
);
14904 if (BASELINK_P (function
))
14905 qualified_p
= true;
14908 nargs
= call_expr_nargs (t
);
14909 call_args
= make_tree_vector ();
14910 for (i
= 0; i
< nargs
; ++i
)
14912 tree arg
= CALL_EXPR_ARG (t
, i
);
14914 if (!PACK_EXPANSION_P (arg
))
14915 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
14918 /* Expand the pack expansion and push each entry onto
14920 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
14921 if (TREE_CODE (arg
) == TREE_VEC
)
14923 unsigned int len
, j
;
14925 len
= TREE_VEC_LENGTH (arg
);
14926 for (j
= 0; j
< len
; ++j
)
14928 tree value
= TREE_VEC_ELT (arg
, j
);
14929 if (value
!= NULL_TREE
)
14930 value
= convert_from_reference (value
);
14931 vec_safe_push (call_args
, value
);
14936 /* A partial substitution. Add one entry. */
14937 vec_safe_push (call_args
, arg
);
14942 /* We do not perform argument-dependent lookup if normal
14943 lookup finds a non-function, in accordance with the
14944 expected resolution of DR 218. */
14946 && ((is_overloaded_fn (function
)
14947 /* If lookup found a member function, the Koenig lookup is
14948 not appropriate, even if an unqualified-name was used
14949 to denote the function. */
14950 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
14951 || identifier_p (function
))
14952 /* Only do this when substitution turns a dependent call
14953 into a non-dependent call. */
14954 && type_dependent_expression_p_push (t
)
14955 && !any_type_dependent_arguments_p (call_args
))
14956 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
14958 if (identifier_p (function
)
14959 && !any_type_dependent_arguments_p (call_args
))
14961 if (koenig_p
&& (complain
& tf_warning_or_error
))
14963 /* For backwards compatibility and good diagnostics, try
14964 the unqualified lookup again if we aren't in SFINAE
14966 tree unq
= (tsubst_copy_and_build
14967 (function
, args
, complain
, in_decl
, true,
14968 integral_constant_expression_p
));
14969 if (unq
== error_mark_node
)
14970 RETURN (error_mark_node
);
14972 if (unq
!= function
)
14975 if (INDIRECT_REF_P (fn
))
14976 fn
= TREE_OPERAND (fn
, 0);
14977 if (TREE_CODE (fn
) == COMPONENT_REF
)
14978 fn
= TREE_OPERAND (fn
, 1);
14979 if (is_overloaded_fn (fn
))
14980 fn
= get_first_fn (fn
);
14981 if (permerror (EXPR_LOC_OR_LOC (t
, input_location
),
14982 "%qD was not declared in this scope, "
14983 "and no declarations were found by "
14984 "argument-dependent lookup at the point "
14985 "of instantiation", function
))
14988 /* Can't say anything more. */;
14989 else if (DECL_CLASS_SCOPE_P (fn
))
14991 location_t loc
= EXPR_LOC_OR_LOC (t
,
14994 "declarations in dependent base %qT are "
14995 "not found by unqualified lookup",
14996 DECL_CLASS_CONTEXT (fn
));
14997 if (current_class_ptr
)
14999 "use %<this->%D%> instead", function
);
15002 "use %<%T::%D%> instead",
15003 current_class_name
, function
);
15006 inform (0, "%q+D declared here, later in the "
15007 "translation unit", fn
);
15012 if (identifier_p (function
))
15014 if (complain
& tf_error
)
15015 unqualified_name_lookup_error (function
);
15016 release_tree_vector (call_args
);
15017 RETURN (error_mark_node
);
15021 /* Remember that there was a reference to this entity. */
15022 if (DECL_P (function
))
15023 mark_used (function
);
15025 /* Put back tf_decltype for the actual call. */
15026 complain
|= decltype_flag
;
15028 if (TREE_CODE (function
) == OFFSET_REF
)
15029 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
15031 else if (TREE_CODE (function
) == COMPONENT_REF
)
15033 tree instance
= TREE_OPERAND (function
, 0);
15034 tree fn
= TREE_OPERAND (function
, 1);
15036 if (processing_template_decl
15037 && (type_dependent_expression_p (instance
)
15038 || (!BASELINK_P (fn
)
15039 && TREE_CODE (fn
) != FIELD_DECL
)
15040 || type_dependent_expression_p (fn
)
15041 || any_type_dependent_arguments_p (call_args
)))
15042 ret
= build_nt_call_vec (function
, call_args
);
15043 else if (!BASELINK_P (fn
))
15044 ret
= finish_call_expr (function
, &call_args
,
15045 /*disallow_virtual=*/false,
15046 /*koenig_p=*/false,
15049 ret
= (build_new_method_call
15051 &call_args
, NULL_TREE
,
15052 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
15057 ret
= finish_call_expr (function
, &call_args
,
15058 /*disallow_virtual=*/qualified_p
,
15062 release_tree_vector (call_args
);
15069 tree cond
= RECUR (TREE_OPERAND (t
, 0));
15072 if (TREE_CODE (cond
) == INTEGER_CST
)
15074 if (integer_zerop (cond
))
15076 ++c_inhibit_evaluation_warnings
;
15077 exp1
= RECUR (TREE_OPERAND (t
, 1));
15078 --c_inhibit_evaluation_warnings
;
15079 exp2
= RECUR (TREE_OPERAND (t
, 2));
15083 exp1
= RECUR (TREE_OPERAND (t
, 1));
15084 ++c_inhibit_evaluation_warnings
;
15085 exp2
= RECUR (TREE_OPERAND (t
, 2));
15086 --c_inhibit_evaluation_warnings
;
15091 exp1
= RECUR (TREE_OPERAND (t
, 1));
15092 exp2
= RECUR (TREE_OPERAND (t
, 2));
15095 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
15096 cond
, exp1
, exp2
, complain
));
15099 case PSEUDO_DTOR_EXPR
:
15101 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15102 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15103 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15104 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
15110 tree purpose
, value
, chain
;
15112 if (t
== void_list_node
)
15115 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
15116 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
15118 /* We have pack expansions, so expand those and
15119 create a new list out of it. */
15120 tree purposevec
= NULL_TREE
;
15121 tree valuevec
= NULL_TREE
;
15125 /* Expand the argument expressions. */
15126 if (TREE_PURPOSE (t
))
15127 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
15128 complain
, in_decl
);
15129 if (TREE_VALUE (t
))
15130 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
15131 complain
, in_decl
);
15133 /* Build the rest of the list. */
15134 chain
= TREE_CHAIN (t
);
15135 if (chain
&& chain
!= void_type_node
)
15136 chain
= RECUR (chain
);
15138 /* Determine the number of arguments. */
15139 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
15141 len
= TREE_VEC_LENGTH (purposevec
);
15142 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
15144 else if (TREE_CODE (valuevec
) == TREE_VEC
)
15145 len
= TREE_VEC_LENGTH (valuevec
);
15148 /* Since we only performed a partial substitution into
15149 the argument pack, we only RETURN (a single list
15151 if (purposevec
== TREE_PURPOSE (t
)
15152 && valuevec
== TREE_VALUE (t
)
15153 && chain
== TREE_CHAIN (t
))
15156 RETURN (tree_cons (purposevec
, valuevec
, chain
));
15159 /* Convert the argument vectors into a TREE_LIST */
15163 /* Grab the Ith values. */
15165 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
15168 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
15171 /* Build the list (backwards). */
15172 chain
= tree_cons (purpose
, value
, chain
);
15178 purpose
= TREE_PURPOSE (t
);
15180 purpose
= RECUR (purpose
);
15181 value
= TREE_VALUE (t
);
15183 value
= RECUR (value
);
15184 chain
= TREE_CHAIN (t
);
15185 if (chain
&& chain
!= void_type_node
)
15186 chain
= RECUR (chain
);
15187 if (purpose
== TREE_PURPOSE (t
)
15188 && value
== TREE_VALUE (t
)
15189 && chain
== TREE_CHAIN (t
))
15191 RETURN (tree_cons (purpose
, value
, chain
));
15194 case COMPONENT_REF
:
15201 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
15202 args
, complain
, in_decl
);
15203 /* Remember that there was a reference to this entity. */
15204 if (DECL_P (object
))
15205 mark_used (object
);
15206 object_type
= TREE_TYPE (object
);
15208 member
= TREE_OPERAND (t
, 1);
15209 if (BASELINK_P (member
))
15210 member
= tsubst_baselink (member
,
15211 non_reference (TREE_TYPE (object
)),
15212 args
, complain
, in_decl
);
15214 member
= tsubst_copy (member
, args
, complain
, in_decl
);
15215 if (member
== error_mark_node
)
15216 RETURN (error_mark_node
);
15218 if (type_dependent_expression_p (object
))
15219 /* We can't do much here. */;
15220 else if (!CLASS_TYPE_P (object_type
))
15222 if (scalarish_type_p (object_type
))
15224 tree s
= NULL_TREE
;
15225 tree dtor
= member
;
15227 if (TREE_CODE (dtor
) == SCOPE_REF
)
15229 s
= TREE_OPERAND (dtor
, 0);
15230 dtor
= TREE_OPERAND (dtor
, 1);
15232 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
15234 dtor
= TREE_OPERAND (dtor
, 0);
15236 RETURN (finish_pseudo_destructor_expr
15237 (object
, s
, dtor
, input_location
));
15241 else if (TREE_CODE (member
) == SCOPE_REF
15242 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
15244 /* Lookup the template functions now that we know what the
15246 tree scope
= TREE_OPERAND (member
, 0);
15247 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
15248 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
15249 member
= lookup_qualified_name (scope
, tmpl
,
15250 /*is_type_p=*/false,
15251 /*complain=*/false);
15252 if (BASELINK_P (member
))
15254 BASELINK_FUNCTIONS (member
)
15255 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
15257 member
= (adjust_result_of_qualified_name_lookup
15258 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
15263 qualified_name_lookup_error (scope
, tmpl
, member
,
15265 RETURN (error_mark_node
);
15268 else if (TREE_CODE (member
) == SCOPE_REF
15269 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
15270 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
15272 if (complain
& tf_error
)
15274 if (TYPE_P (TREE_OPERAND (member
, 0)))
15275 error ("%qT is not a class or namespace",
15276 TREE_OPERAND (member
, 0));
15278 error ("%qD is not a class or namespace",
15279 TREE_OPERAND (member
, 0));
15281 RETURN (error_mark_node
);
15283 else if (TREE_CODE (member
) == FIELD_DECL
)
15285 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
15286 if (TREE_CODE (r
) == COMPONENT_REF
)
15287 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15291 r
= finish_class_member_access_expr (object
, member
,
15292 /*template_p=*/false,
15294 if (TREE_CODE (r
) == COMPONENT_REF
)
15295 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
15300 RETURN (build_throw
15301 (RECUR (TREE_OPERAND (t
, 0))));
15305 vec
<constructor_elt
, va_gc
> *n
;
15306 constructor_elt
*ce
;
15307 unsigned HOST_WIDE_INT idx
;
15308 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15309 bool process_index_p
;
15311 bool need_copy_p
= false;
15314 if (type
== error_mark_node
)
15315 RETURN (error_mark_node
);
15317 /* digest_init will do the wrong thing if we let it. */
15318 if (type
&& TYPE_PTRMEMFUNC_P (type
))
15321 /* We do not want to process the index of aggregate
15322 initializers as they are identifier nodes which will be
15323 looked up by digest_init. */
15324 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
15326 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
15327 newlen
= vec_safe_length (n
);
15328 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
15330 if (ce
->index
&& process_index_p
15331 /* An identifier index is looked up in the type
15332 being initialized, not the current scope. */
15333 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
15334 ce
->index
= RECUR (ce
->index
);
15336 if (PACK_EXPANSION_P (ce
->value
))
15338 /* Substitute into the pack expansion. */
15339 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
15342 if (ce
->value
== error_mark_node
15343 || PACK_EXPANSION_P (ce
->value
))
15345 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
15346 /* Just move the argument into place. */
15347 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
15350 /* Update the length of the final CONSTRUCTOR
15351 arguments vector, and note that we will need to
15353 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
15354 need_copy_p
= true;
15358 ce
->value
= RECUR (ce
->value
);
15363 vec
<constructor_elt
, va_gc
> *old_n
= n
;
15365 vec_alloc (n
, newlen
);
15366 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
15368 if (TREE_CODE (ce
->value
) == TREE_VEC
)
15370 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
15371 for (i
= 0; i
< len
; ++i
)
15372 CONSTRUCTOR_APPEND_ELT (n
, 0,
15373 TREE_VEC_ELT (ce
->value
, i
));
15376 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
15380 r
= build_constructor (init_list_type_node
, n
);
15381 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
15383 if (TREE_HAS_CONSTRUCTOR (t
))
15384 RETURN (finish_compound_literal (type
, r
, complain
));
15386 TREE_TYPE (r
) = type
;
15392 tree operand_0
= TREE_OPERAND (t
, 0);
15393 if (TYPE_P (operand_0
))
15395 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
15396 RETURN (get_typeid (operand_0
, complain
));
15400 operand_0
= RECUR (operand_0
);
15401 RETURN (build_typeid (operand_0
, complain
));
15408 else if (DECL_PACK_P (t
))
15410 /* We don't build decls for an instantiation of a
15411 variadic capture proxy, we instantiate the elements
15413 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
15414 return RECUR (DECL_VALUE_EXPR (t
));
15420 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
15422 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
15423 /* If the original type was a reference, we'll be wrapped in
15424 the appropriate INDIRECT_REF. */
15425 r
= convert_from_reference (r
);
15431 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15432 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15433 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
15436 case OFFSETOF_EXPR
:
15437 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t
, 0))));
15441 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
15442 complain
, in_decl
);
15444 tree type2
= TRAIT_EXPR_TYPE2 (t
);
15446 type2
= tsubst (type2
, args
, complain
, in_decl
);
15448 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
15453 tree old_stmt_expr
= cur_stmt_expr
;
15454 tree stmt_expr
= begin_stmt_expr ();
15456 cur_stmt_expr
= stmt_expr
;
15457 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
15458 integral_constant_expression_p
);
15459 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
15460 cur_stmt_expr
= old_stmt_expr
;
15462 /* If the resulting list of expression statement is empty,
15463 fold it further into void_node. */
15464 if (empty_expr_stmt_p (stmt_expr
))
15465 stmt_expr
= void_node
;
15467 RETURN (stmt_expr
);
15472 tree r
= build_lambda_expr ();
15474 tree type
= tsubst (LAMBDA_EXPR_CLOSURE (t
), args
, complain
, NULL_TREE
);
15475 LAMBDA_EXPR_CLOSURE (r
) = type
;
15476 CLASSTYPE_LAMBDA_EXPR (type
) = r
;
15478 LAMBDA_EXPR_LOCATION (r
)
15479 = LAMBDA_EXPR_LOCATION (t
);
15480 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
15481 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
15482 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
15483 LAMBDA_EXPR_DISCRIMINATOR (r
)
15484 = (LAMBDA_EXPR_DISCRIMINATOR (t
));
15485 /* For a function scope, we want to use tsubst so that we don't
15486 complain about referring to an auto function before its return
15487 type has been deduced. Otherwise, we want to use tsubst_copy so
15488 that we look up the existing field/parameter/variable rather
15489 than build a new one. */
15490 tree scope
= LAMBDA_EXPR_EXTRA_SCOPE (t
);
15491 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15492 scope
= tsubst (scope
, args
, complain
, in_decl
);
15493 else if (scope
&& TREE_CODE (scope
) == PARM_DECL
)
15495 /* Look up the parameter we want directly, as tsubst_copy
15496 doesn't do what we need. */
15497 tree fn
= tsubst (DECL_CONTEXT (scope
), args
, complain
, in_decl
);
15498 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
15499 while (DECL_PARM_INDEX (parm
) != DECL_PARM_INDEX (scope
))
15500 parm
= DECL_CHAIN (parm
);
15502 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15503 if (DECL_CONTEXT (scope
) == NULL_TREE
)
15504 DECL_CONTEXT (scope
) = fn
;
15507 scope
= RECUR (scope
);
15508 LAMBDA_EXPR_EXTRA_SCOPE (r
) = scope
;
15509 LAMBDA_EXPR_RETURN_TYPE (r
)
15510 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t
), args
, complain
, in_decl
);
15512 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
15513 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
15515 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15516 determine_visibility (TYPE_NAME (type
));
15517 /* Now that we know visibility, instantiate the type so we have a
15518 declaration of the op() for later calls to lambda_function. */
15519 complete_type (type
);
15521 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
15523 RETURN (build_lambda_object (r
));
15527 /* We can get here for a constant initializer of non-dependent type.
15528 FIXME stop folding in cp_parser_initializer_clause. */
15530 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
15535 case TRANSACTION_EXPR
:
15536 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
15537 integral_constant_expression_p
));
15540 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
15542 case VEC_PERM_EXPR
:
15544 tree op0
= RECUR (TREE_OPERAND (t
, 0));
15545 tree op1
= RECUR (TREE_OPERAND (t
, 1));
15546 tree op2
= RECUR (TREE_OPERAND (t
, 2));
15547 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
15552 /* Handle Objective-C++ constructs, if appropriate. */
15555 = objcp_tsubst_copy_and_build (t
, args
, complain
,
15556 in_decl
, /*function_p=*/false);
15560 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
15566 input_location
= loc
;
15570 /* Verify that the instantiated ARGS are valid. For type arguments,
15571 make sure that the type's linkage is ok. For non-type arguments,
15572 make sure they are constants if they are integral or enumerations.
15573 Emit an error under control of COMPLAIN, and return TRUE on error. */
15576 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
15578 if (dependent_template_arg_p (t
))
15580 if (ARGUMENT_PACK_P (t
))
15582 tree vec
= ARGUMENT_PACK_ARGS (t
);
15583 int len
= TREE_VEC_LENGTH (vec
);
15584 bool result
= false;
15587 for (i
= 0; i
< len
; ++i
)
15588 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
15592 else if (TYPE_P (t
))
15594 /* [basic.link]: A name with no linkage (notably, the name
15595 of a class or enumeration declared in a local scope)
15596 shall not be used to declare an entity with linkage.
15597 This implies that names with no linkage cannot be used as
15600 DR 757 relaxes this restriction for C++0x. */
15601 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
15602 : no_linkage_check (t
, /*relaxed_p=*/false));
15606 /* DR 488 makes use of a type with no linkage cause
15607 type deduction to fail. */
15608 if (complain
& tf_error
)
15610 if (TYPE_ANONYMOUS_P (nt
))
15611 error ("%qT is/uses anonymous type", t
);
15613 error ("template argument for %qD uses local type %qT",
15618 /* In order to avoid all sorts of complications, we do not
15619 allow variably-modified types as template arguments. */
15620 else if (variably_modified_type_p (t
, NULL_TREE
))
15622 if (complain
& tf_error
)
15623 error ("%qT is a variably modified type", t
);
15627 /* Class template and alias template arguments should be OK. */
15628 else if (DECL_TYPE_TEMPLATE_P (t
))
15630 /* A non-type argument of integral or enumerated type must be a
15632 else if (TREE_TYPE (t
)
15633 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
15634 && !TREE_CONSTANT (t
))
15636 if (complain
& tf_error
)
15637 error ("integral expression %qE is not constant", t
);
15644 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
15646 int ix
, len
= DECL_NTPARMS (tmpl
);
15647 bool result
= false;
15649 for (ix
= 0; ix
!= len
; ix
++)
15651 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
15654 if (result
&& (complain
& tf_error
))
15655 error (" trying to instantiate %qD", tmpl
);
15659 /* We're out of SFINAE context now, so generate diagnostics for the access
15660 errors we saw earlier when instantiating D from TMPL and ARGS. */
15663 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
15665 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
15666 tree type
= TREE_TYPE (pattern
);
15667 location_t loc
= input_location
;
15669 push_access_scope (d
);
15670 push_deferring_access_checks (dk_no_deferred
);
15671 input_location
= DECL_SOURCE_LOCATION (pattern
);
15672 tsubst (type
, args
, tf_warning_or_error
, d
);
15673 input_location
= loc
;
15674 pop_deferring_access_checks ();
15675 pop_access_scope (d
);
15678 /* Instantiate the indicated variable, function, or alias template TMPL with
15679 the template arguments in TARG_PTR. */
15682 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15684 tree targ_ptr
= orig_args
;
15688 bool access_ok
= true;
15690 if (tmpl
== error_mark_node
)
15691 return error_mark_node
;
15693 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
15695 /* If this function is a clone, handle it specially. */
15696 if (DECL_CLONED_FUNCTION_P (tmpl
))
15701 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15702 DECL_CLONED_FUNCTION. */
15703 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
15704 targ_ptr
, complain
);
15705 if (spec
== error_mark_node
)
15706 return error_mark_node
;
15708 /* Look for the clone. */
15709 FOR_EACH_CLONE (clone
, spec
)
15710 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
15712 /* We should always have found the clone by now. */
15713 gcc_unreachable ();
15717 if (targ_ptr
== error_mark_node
)
15718 return error_mark_node
;
15720 /* Check to see if we already have this specialization. */
15721 gen_tmpl
= most_general_template (tmpl
);
15722 if (tmpl
!= gen_tmpl
)
15723 /* The TMPL is a partial instantiation. To get a full set of
15724 arguments we must add the arguments used to perform the
15725 partial instantiation. */
15726 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
15729 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15730 but it doesn't seem to be on the hot path. */
15731 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
15733 gcc_assert (tmpl
== gen_tmpl
15734 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
15736 || fndecl
== NULL_TREE
);
15738 if (spec
!= NULL_TREE
)
15740 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
15742 if (complain
& tf_error
)
15743 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
15744 return error_mark_node
;
15749 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
15751 return error_mark_node
;
15753 /* We are building a FUNCTION_DECL, during which the access of its
15754 parameters and return types have to be checked. However this
15755 FUNCTION_DECL which is the desired context for access checking
15756 is not built yet. We solve this chicken-and-egg problem by
15757 deferring all checks until we have the FUNCTION_DECL. */
15758 push_deferring_access_checks (dk_deferred
);
15760 /* Instantiation of the function happens in the context of the function
15761 template, not the context of the overload resolution we're doing. */
15762 push_to_top_level ();
15763 /* If there are dependent arguments, e.g. because we're doing partial
15764 ordering, make sure processing_template_decl stays set. */
15765 if (uses_template_parms (targ_ptr
))
15766 ++processing_template_decl
;
15767 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15769 tree ctx
= tsubst (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
15770 complain
, gen_tmpl
);
15771 push_nested_class (ctx
);
15773 /* Substitute template parameters to obtain the specialization. */
15774 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
15775 targ_ptr
, complain
, gen_tmpl
);
15776 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
15777 pop_nested_class ();
15778 pop_from_top_level ();
15780 if (fndecl
== error_mark_node
)
15782 pop_deferring_access_checks ();
15783 return error_mark_node
;
15786 /* The DECL_TI_TEMPLATE should always be the immediate parent
15787 template, not the most general template. */
15788 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
15790 /* Now we know the specialization, compute access previously
15792 push_access_scope (fndecl
);
15793 if (!perform_deferred_access_checks (complain
))
15795 pop_access_scope (fndecl
);
15796 pop_deferring_access_checks ();
15798 /* If we've just instantiated the main entry point for a function,
15799 instantiate all the alternate entry points as well. We do this
15800 by cloning the instantiation of the main entry point, not by
15801 instantiating the template clones. */
15802 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
15803 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
15807 if (!(complain
& tf_error
))
15809 /* Remember to reinstantiate when we're out of SFINAE so the user
15810 can see the errors. */
15811 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
15813 return error_mark_node
;
15818 /* Wrapper for instantiate_template_1. */
15821 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
15824 timevar_push (TV_TEMPLATE_INST
);
15825 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
15826 timevar_pop (TV_TEMPLATE_INST
);
15830 /* Instantiate the alias template TMPL with ARGS. Also push a template
15831 instantiation level, which instantiate_template doesn't do because
15832 functions and variables have sufficient context established by the
15836 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
15838 struct pending_template
*old_last_pend
= last_pending_template
;
15839 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15840 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
15841 return error_mark_node
;
15842 tree tinst
= build_tree_list (tmpl
, args
);
15843 if (!push_tinst_level (tinst
))
15846 return error_mark_node
;
15850 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
15851 args
, tmpl
, complain
,
15852 /*require_all_args=*/true,
15853 /*use_default_args=*/true);
15855 tree r
= instantiate_template (tmpl
, args
, complain
);
15856 pop_tinst_level ();
15857 /* We can't free this if a pending_template entry or last_error_tinst_level
15858 is pointing at it. */
15859 if (last_pending_template
== old_last_pend
15860 && last_error_tinst_level
== old_error_tinst
)
15866 /* PARM is a template parameter pack for FN. Returns true iff
15867 PARM is used in a deducible way in the argument list of FN. */
15870 pack_deducible_p (tree parm
, tree fn
)
15872 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
15873 for (; t
; t
= TREE_CHAIN (t
))
15875 tree type
= TREE_VALUE (t
);
15877 if (!PACK_EXPANSION_P (type
))
15879 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
15880 packs
; packs
= TREE_CHAIN (packs
))
15881 if (template_args_equal (TREE_VALUE (packs
), parm
))
15883 /* The template parameter pack is used in a function parameter
15884 pack. If this is the end of the parameter list, the
15885 template parameter pack is deducible. */
15886 if (TREE_CHAIN (t
) == void_list_node
)
15889 /* Otherwise, not. Well, it could be deduced from
15890 a non-pack parameter, but doing so would end up with
15891 a deduction mismatch, so don't bother. */
15895 /* The template parameter pack isn't used in any function parameter
15896 packs, but it might be used deeper, e.g. tuple<Args...>. */
15900 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
15901 NARGS elements of the arguments that are being used when calling
15902 it. TARGS is a vector into which the deduced template arguments
15905 Returns either a FUNCTION_DECL for the matching specialization of FN or
15906 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
15907 true, diagnostics will be printed to explain why it failed.
15909 If FN is a conversion operator, or we are trying to produce a specific
15910 specialization, RETURN_TYPE is the return type desired.
15912 The EXPLICIT_TARGS are explicit template arguments provided via a
15915 The parameter STRICT is one of:
15918 We are deducing arguments for a function call, as in
15919 [temp.deduct.call].
15922 We are deducing arguments for a conversion function, as in
15923 [temp.deduct.conv].
15926 We are deducing arguments when doing an explicit instantiation
15927 as in [temp.explicit], when determining an explicit specialization
15928 as in [temp.expl.spec], or when taking the address of a function
15929 template, as in [temp.deduct.funcaddr]. */
15932 fn_type_unification (tree fn
,
15933 tree explicit_targs
,
15936 unsigned int nargs
,
15938 unification_kind_t strict
,
15945 tree decl
= NULL_TREE
;
15946 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
15948 static int deduction_depth
;
15949 struct pending_template
*old_last_pend
= last_pending_template
;
15950 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
15951 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
15953 tree r
= error_mark_node
;
15956 complain
|= tf_decltype
;
15958 /* In C++0x, it's possible to have a function template whose type depends
15959 on itself recursively. This is most obvious with decltype, but can also
15960 occur with enumeration scope (c++/48969). So we need to catch infinite
15961 recursion and reject the substitution at deduction time; this function
15962 will return error_mark_node for any repeated substitution.
15964 This also catches excessive recursion such as when f<N> depends on
15965 f<N-1> across all integers, and returns error_mark_node for all the
15966 substitutions back up to the initial one.
15968 This is, of course, not reentrant. */
15969 if (excessive_deduction_depth
)
15970 return error_mark_node
;
15971 tinst
= build_tree_list (fn
, NULL_TREE
);
15974 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
15976 fntype
= TREE_TYPE (fn
);
15977 if (explicit_targs
)
15981 The specified template arguments must match the template
15982 parameters in kind (i.e., type, nontype, template), and there
15983 must not be more arguments than there are parameters;
15984 otherwise type deduction fails.
15986 Nontype arguments must match the types of the corresponding
15987 nontype template parameters, or must be convertible to the
15988 types of the corresponding nontype parameters as specified in
15989 _temp.arg.nontype_, otherwise type deduction fails.
15991 All references in the function type of the function template
15992 to the corresponding template parameters are replaced by the
15993 specified template argument values. If a substitution in a
15994 template parameter or in the function type of the function
15995 template results in an invalid type, type deduction fails. */
15996 int i
, len
= TREE_VEC_LENGTH (tparms
);
15997 location_t loc
= input_location
;
15998 bool incomplete
= false;
16000 /* Adjust any explicit template arguments before entering the
16001 substitution context. */
16003 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
16005 /*require_all_args=*/false,
16006 /*use_default_args=*/false));
16007 if (explicit_targs
== error_mark_node
)
16010 /* Substitute the explicit args into the function type. This is
16011 necessary so that, for instance, explicitly declared function
16012 arguments can match null pointed constants. If we were given
16013 an incomplete set of explicit args, we must not do semantic
16014 processing during substitution as we could create partial
16016 for (i
= 0; i
< len
; i
++)
16018 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16019 bool parameter_pack
= false;
16020 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
16022 /* Dig out the actual parm. */
16023 if (TREE_CODE (parm
) == TYPE_DECL
16024 || TREE_CODE (parm
) == TEMPLATE_DECL
)
16026 parm
= TREE_TYPE (parm
);
16027 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
16029 else if (TREE_CODE (parm
) == PARM_DECL
)
16031 parm
= DECL_INITIAL (parm
);
16032 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
16035 if (!parameter_pack
&& targ
== NULL_TREE
)
16036 /* No explicit argument for this template parameter. */
16039 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
16041 /* Mark the argument pack as "incomplete". We could
16042 still deduce more arguments during unification.
16043 We remove this mark in type_unification_real. */
16046 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
16047 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
16048 = ARGUMENT_PACK_ARGS (targ
);
16051 /* We have some incomplete argument packs. */
16056 TREE_VALUE (tinst
) = explicit_targs
;
16057 if (!push_tinst_level (tinst
))
16059 excessive_deduction_depth
= true;
16062 processing_template_decl
+= incomplete
;
16063 input_location
= DECL_SOURCE_LOCATION (fn
);
16064 /* Ignore any access checks; we'll see them again in
16065 instantiate_template and they might have the wrong
16066 access path at this point. */
16067 push_deferring_access_checks (dk_deferred
);
16068 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
16069 complain
| tf_partial
, NULL_TREE
);
16070 pop_deferring_access_checks ();
16071 input_location
= loc
;
16072 processing_template_decl
-= incomplete
;
16073 pop_tinst_level ();
16075 if (fntype
== error_mark_node
)
16078 /* Place the explicitly specified arguments in TARGS. */
16079 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
16080 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
16083 /* Never do unification on the 'this' parameter. */
16084 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
16090 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
16091 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
16092 new_args
[0] = return_type
;
16093 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
16098 /* We allow incomplete unification without an error message here
16099 because the standard doesn't seem to explicitly prohibit it. Our
16100 callers must be ready to deal with unification failures in any
16103 TREE_VALUE (tinst
) = targs
;
16104 /* If we aren't explaining yet, push tinst context so we can see where
16105 any errors (e.g. from class instantiations triggered by instantiation
16106 of default template arguments) come from. If we are explaining, this
16107 context is redundant. */
16108 if (!explain_p
&& !push_tinst_level (tinst
))
16110 excessive_deduction_depth
= true;
16114 /* type_unification_real will pass back any access checks from default
16115 template argument substitution. */
16116 vec
<deferred_access_check
, va_gc
> *checks
;
16119 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16120 targs
, parms
, args
, nargs
, /*subr=*/0,
16121 strict
, flags
, &checks
, explain_p
);
16123 pop_tinst_level ();
16127 /* Now that we have bindings for all of the template arguments,
16128 ensure that the arguments deduced for the template template
16129 parameters have compatible template parameter lists. We cannot
16130 check this property before we have deduced all template
16131 arguments, because the template parameter types of a template
16132 template parameter might depend on prior template parameters
16133 deduced after the template template parameter. The following
16134 ill-formed example illustrates this issue:
16136 template<typename T, template<T> class C> void f(C<5>, T);
16138 template<int N> struct X {};
16141 f(X<5>(), 5l); // error: template argument deduction fails
16144 The template parameter list of 'C' depends on the template type
16145 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16146 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16147 time that we deduce 'C'. */
16148 if (!template_template_parm_bindings_ok_p
16149 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
16151 unify_inconsistent_template_template_parameters (explain_p
);
16155 /* All is well so far. Now, check:
16159 When all template arguments have been deduced, all uses of
16160 template parameters in nondeduced contexts are replaced with
16161 the corresponding deduced argument values. If the
16162 substitution results in an invalid type, as described above,
16163 type deduction fails. */
16164 TREE_VALUE (tinst
) = targs
;
16165 if (!push_tinst_level (tinst
))
16167 excessive_deduction_depth
= true;
16171 /* Also collect access checks from the instantiation. */
16172 reopen_deferring_access_checks (checks
);
16174 decl
= instantiate_template (fn
, targs
, complain
);
16176 checks
= get_deferred_access_checks ();
16177 pop_deferring_access_checks ();
16179 pop_tinst_level ();
16181 if (decl
== error_mark_node
)
16184 /* Now perform any access checks encountered during substitution. */
16185 push_access_scope (decl
);
16186 ok
= perform_access_checks (checks
, complain
);
16187 pop_access_scope (decl
);
16191 /* If we're looking for an exact match, check that what we got
16192 is indeed an exact match. It might not be if some template
16193 parameters are used in non-deduced contexts. But don't check
16194 for an exact match if we have dependent template arguments;
16195 in that case we're doing partial ordering, and we already know
16196 that we have two candidates that will provide the actual type. */
16197 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
16199 tree substed
= TREE_TYPE (decl
);
16203 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
16205 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
16206 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
16207 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
16209 unify_type_mismatch (explain_p
, args
[i
],
16210 TREE_VALUE (sarg
));
16219 if (excessive_deduction_depth
)
16221 if (deduction_depth
== 0)
16222 /* Reset once we're all the way out. */
16223 excessive_deduction_depth
= false;
16226 /* We can't free this if a pending_template entry or last_error_tinst_level
16227 is pointing at it. */
16228 if (last_pending_template
== old_last_pend
16229 && last_error_tinst_level
== old_error_tinst
)
16235 /* Adjust types before performing type deduction, as described in
16236 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16237 sections are symmetric. PARM is the type of a function parameter
16238 or the return type of the conversion function. ARG is the type of
16239 the argument passed to the call, or the type of the value
16240 initialized with the result of the conversion function.
16241 ARG_EXPR is the original argument expression, which may be null. */
16244 maybe_adjust_types_for_deduction (unification_kind_t strict
,
16258 /* Swap PARM and ARG throughout the remainder of this
16259 function; the handling is precisely symmetric since PARM
16260 will initialize ARG rather than vice versa. */
16268 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16269 too, but here handle it by stripping the reference from PARM
16270 rather than by adding it to ARG. */
16271 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16272 && TYPE_REF_IS_RVALUE (*parm
)
16273 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16274 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16275 && TREE_CODE (*arg
) == REFERENCE_TYPE
16276 && !TYPE_REF_IS_RVALUE (*arg
))
16277 *parm
= TREE_TYPE (*parm
);
16278 /* Nothing else to do in this case. */
16282 gcc_unreachable ();
16285 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
16287 /* [temp.deduct.call]
16289 If P is not a reference type:
16291 --If A is an array type, the pointer type produced by the
16292 array-to-pointer standard conversion (_conv.array_) is
16293 used in place of A for type deduction; otherwise,
16295 --If A is a function type, the pointer type produced by
16296 the function-to-pointer standard conversion
16297 (_conv.func_) is used in place of A for type deduction;
16300 --If A is a cv-qualified type, the top level
16301 cv-qualifiers of A's type are ignored for type
16303 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
16304 *arg
= build_pointer_type (TREE_TYPE (*arg
));
16305 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
16306 *arg
= build_pointer_type (*arg
);
16308 *arg
= TYPE_MAIN_VARIANT (*arg
);
16311 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16312 of the form T&&, where T is a template parameter, and the argument
16313 is an lvalue, T is deduced as A& */
16314 if (TREE_CODE (*parm
) == REFERENCE_TYPE
16315 && TYPE_REF_IS_RVALUE (*parm
)
16316 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
16317 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
16318 && (arg_expr
? real_lvalue_p (arg_expr
)
16319 /* try_one_overload doesn't provide an arg_expr, but
16320 functions are always lvalues. */
16321 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
16322 *arg
= build_reference_type (*arg
);
16324 /* [temp.deduct.call]
16326 If P is a cv-qualified type, the top level cv-qualifiers
16327 of P's type are ignored for type deduction. If P is a
16328 reference type, the type referred to by P is used for
16330 *parm
= TYPE_MAIN_VARIANT (*parm
);
16331 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
16333 *parm
= TREE_TYPE (*parm
);
16334 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
16337 /* DR 322. For conversion deduction, remove a reference type on parm
16338 too (which has been swapped into ARG). */
16339 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
16340 *arg
= TREE_TYPE (*arg
);
16345 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16346 template which does contain any deducible template parameters; check if
16347 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16348 unify_one_argument. */
16351 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
16352 int flags
, bool explain_p
)
16357 type
= TREE_TYPE (arg
);
16361 if (same_type_p (parm
, type
))
16362 return unify_success (explain_p
);
16364 if (strict
== DEDUCE_CONV
)
16366 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
16367 explain_p
? tf_warning_or_error
: tf_none
))
16368 return unify_success (explain_p
);
16370 else if (strict
!= DEDUCE_EXACT
)
16372 if (can_convert_arg (parm
, type
,
16373 TYPE_P (arg
) ? NULL_TREE
: arg
,
16374 flags
, explain_p
? tf_warning_or_error
: tf_none
))
16375 return unify_success (explain_p
);
16378 if (strict
== DEDUCE_EXACT
)
16379 return unify_type_mismatch (explain_p
, parm
, arg
);
16381 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
16384 static bool uses_deducible_template_parms (tree type
);
16386 /* Returns true iff the expression EXPR is one from which a template
16387 argument can be deduced. In other words, if it's an undecorated
16388 use of a template non-type parameter. */
16391 deducible_expression (tree expr
)
16393 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
16396 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16397 deducible way; that is, if it has a max value of <PARM> - 1. */
16400 deducible_array_bound (tree domain
)
16402 if (domain
== NULL_TREE
)
16405 tree max
= TYPE_MAX_VALUE (domain
);
16406 if (TREE_CODE (max
) != MINUS_EXPR
)
16409 return deducible_expression (TREE_OPERAND (max
, 0));
16412 /* Returns true iff the template arguments ARGS use a template parameter
16413 in a deducible way. */
16416 deducible_template_args (tree args
)
16418 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
16421 tree elt
= TREE_VEC_ELT (args
, i
);
16422 if (ARGUMENT_PACK_P (elt
))
16423 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
16426 if (PACK_EXPANSION_P (elt
))
16427 elt
= PACK_EXPANSION_PATTERN (elt
);
16428 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
16430 else if (TYPE_P (elt
))
16431 deducible
= uses_deducible_template_parms (elt
);
16433 deducible
= deducible_expression (elt
);
16441 /* Returns true iff TYPE contains any deducible references to template
16442 parameters, as per 14.8.2.5. */
16445 uses_deducible_template_parms (tree type
)
16447 if (PACK_EXPANSION_P (type
))
16448 type
= PACK_EXPANSION_PATTERN (type
);
16455 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
16456 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
16462 if (POINTER_TYPE_P (type
))
16463 return uses_deducible_template_parms (TREE_TYPE (type
));
16465 /* T[integer-constant ]
16467 if (TREE_CODE (type
) == ARRAY_TYPE
)
16468 return (uses_deducible_template_parms (TREE_TYPE (type
))
16469 || deducible_array_bound (TYPE_DOMAIN (type
)));
16481 if (TYPE_PTRMEM_P (type
))
16482 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
16483 || (uses_deducible_template_parms
16484 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
16486 /* template-name <T> (where template-name refers to a class template)
16487 template-name <i> (where template-name refers to a class template) */
16488 if (CLASS_TYPE_P (type
)
16489 && CLASSTYPE_TEMPLATE_INFO (type
)
16490 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
16491 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16492 (CLASSTYPE_TI_ARGS (type
)));
16497 if (TREE_CODE (type
) == FUNCTION_TYPE
16498 || TREE_CODE (type
) == METHOD_TYPE
)
16500 if (uses_deducible_template_parms (TREE_TYPE (type
)))
16502 tree parm
= TYPE_ARG_TYPES (type
);
16503 if (TREE_CODE (type
) == METHOD_TYPE
)
16504 parm
= TREE_CHAIN (parm
);
16505 for (; parm
; parm
= TREE_CHAIN (parm
))
16506 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
16513 /* Subroutine of type_unification_real and unify_pack_expansion to
16514 handle unification of a single P/A pair. Parameters are as
16515 for those functions. */
16518 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
16519 int subr
, unification_kind_t strict
, int flags
,
16522 tree arg_expr
= NULL_TREE
;
16525 if (arg
== error_mark_node
|| parm
== error_mark_node
)
16526 return unify_invalid (explain_p
);
16527 if (arg
== unknown_type_node
)
16528 /* We can't deduce anything from this, but we might get all the
16529 template args from other function args. */
16530 return unify_success (explain_p
);
16532 /* Implicit conversions (Clause 4) will be performed on a function
16533 argument to convert it to the type of the corresponding function
16534 parameter if the parameter type contains no template-parameters that
16535 participate in template argument deduction. */
16536 if (TYPE_P (parm
) && !uses_template_parms (parm
))
16537 /* For function parameters that contain no template-parameters at all,
16538 we have historically checked for convertibility in order to shortcut
16539 consideration of this candidate. */
16540 return check_non_deducible_conversion (parm
, arg
, strict
, flags
,
16542 else if (strict
== DEDUCE_CALL
16543 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
16544 /* For function parameters with only non-deducible template parameters,
16546 return unify_success (explain_p
);
16551 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
16552 | UNIFY_ALLOW_MORE_CV_QUAL
16553 | UNIFY_ALLOW_DERIVED
);
16557 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
16561 arg_strict
= UNIFY_ALLOW_NONE
;
16565 gcc_unreachable ();
16568 /* We only do these transformations if this is the top-level
16569 parameter_type_list in a call or declaration matching; in other
16570 situations (nested function declarators, template argument lists) we
16571 won't be comparing a type to an expression, and we don't do any type
16577 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
16578 if (type_unknown_p (arg
))
16580 /* [temp.deduct.type] A template-argument can be
16581 deduced from a pointer to function or pointer
16582 to member function argument if the set of
16583 overloaded functions does not contain function
16584 templates and at most one of a set of
16585 overloaded functions provides a unique
16588 if (resolve_overloaded_unification
16589 (tparms
, targs
, parm
, arg
, strict
,
16590 arg_strict
, explain_p
))
16591 return unify_success (explain_p
);
16592 return unify_overload_resolution_failure (explain_p
, arg
);
16596 arg
= unlowered_expr_type (arg
);
16597 if (arg
== error_mark_node
)
16598 return unify_invalid (explain_p
);
16602 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
16605 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
16606 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
16607 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
16609 /* For deduction from an init-list we need the actual list. */
16610 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
16612 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
16615 /* Most parms like fn_type_unification.
16617 If SUBR is 1, we're being called recursively (to unify the
16618 arguments of a function or method parameter of a function
16621 CHECKS is a pointer to a vector of access checks encountered while
16622 substituting default template arguments. */
16625 type_unification_real (tree tparms
,
16629 unsigned int xnargs
,
16631 unification_kind_t strict
,
16633 vec
<deferred_access_check
, va_gc
> **checks
,
16638 int ntparms
= TREE_VEC_LENGTH (tparms
);
16639 int saw_undeduced
= 0;
16642 unsigned int nargs
;
16645 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
16646 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
16647 gcc_assert (ntparms
> 0);
16649 /* Reset the number of non-defaulted template arguments contained
16651 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
16659 while (parms
&& parms
!= void_list_node
16662 parm
= TREE_VALUE (parms
);
16664 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
16665 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
16666 /* For a function parameter pack that occurs at the end of the
16667 parameter-declaration-list, the type A of each remaining
16668 argument of the call is compared with the type P of the
16669 declarator-id of the function parameter pack. */
16672 parms
= TREE_CHAIN (parms
);
16674 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
16675 /* For a function parameter pack that does not occur at the
16676 end of the parameter-declaration-list, the type of the
16677 parameter pack is a non-deduced context. */
16683 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
16689 && parms
!= void_list_node
16690 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
16692 /* Unify the remaining arguments with the pack expansion type. */
16694 tree parmvec
= make_tree_vec (1);
16696 /* Allocate a TREE_VEC and copy in all of the arguments */
16697 argvec
= make_tree_vec (nargs
- ia
);
16698 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
16699 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
16701 /* Copy the parameter into parmvec. */
16702 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
16703 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
16704 /*subr=*/subr
, explain_p
))
16707 /* Advance to the end of the list of parameters. */
16708 parms
= TREE_CHAIN (parms
);
16711 /* Fail if we've reached the end of the parm list, and more args
16712 are present, and the parm list isn't variadic. */
16713 if (ia
< nargs
&& parms
== void_list_node
)
16714 return unify_too_many_arguments (explain_p
, nargs
, ia
);
16715 /* Fail if parms are left and they don't have default values and
16716 they aren't all deduced as empty packs (c++/57397). This is
16717 consistent with sufficient_parms_p. */
16718 if (parms
&& parms
!= void_list_node
16719 && TREE_PURPOSE (parms
) == NULL_TREE
)
16721 unsigned int count
= nargs
;
16726 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
16729 p
= TREE_CHAIN (p
);
16731 while (p
&& p
!= void_list_node
);
16732 if (count
!= nargs
)
16733 return unify_too_few_arguments (explain_p
, ia
, count
,
16739 tsubst_flags_t complain
= (explain_p
16740 ? tf_warning_or_error
16743 for (i
= 0; i
< ntparms
; i
++)
16745 tree targ
= TREE_VEC_ELT (targs
, i
);
16746 tree tparm
= TREE_VEC_ELT (tparms
, i
);
16748 /* Clear the "incomplete" flags on all argument packs now so that
16749 substituting them into later default arguments works. */
16750 if (targ
&& ARGUMENT_PACK_P (targ
))
16752 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
16753 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
16756 if (targ
|| tparm
== error_mark_node
)
16758 tparm
= TREE_VALUE (tparm
);
16760 /* If this is an undeduced nontype parameter that depends on
16761 a type parameter, try another pass; its type may have been
16762 deduced from a later argument than the one from which
16763 this parameter can be deduced. */
16764 if (TREE_CODE (tparm
) == PARM_DECL
16765 && uses_template_parms (TREE_TYPE (tparm
))
16766 && !saw_undeduced
++)
16769 /* Core issue #226 (C++0x) [temp.deduct]:
16771 If a template argument has not been deduced, its
16772 default template argument, if any, is used.
16774 When we are in C++98 mode, TREE_PURPOSE will either
16775 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16776 to explicitly check cxx_dialect here. */
16777 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
16779 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
16780 tree arg
= TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
));
16781 reopen_deferring_access_checks (*checks
);
16782 location_t save_loc
= input_location
;
16784 input_location
= DECL_SOURCE_LOCATION (parm
);
16785 arg
= tsubst_template_arg (arg
, targs
, complain
, NULL_TREE
);
16786 arg
= convert_template_argument (parm
, arg
, targs
, complain
,
16788 input_location
= save_loc
;
16789 *checks
= get_deferred_access_checks ();
16790 pop_deferring_access_checks ();
16791 if (arg
== error_mark_node
)
16795 TREE_VEC_ELT (targs
, i
) = arg
;
16796 /* The position of the first default template argument,
16797 is also the number of non-defaulted arguments in TARGS.
16799 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16800 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
16805 /* If the type parameter is a parameter pack, then it will
16806 be deduced to an empty parameter pack. */
16807 if (template_parameter_pack_p (tparm
))
16811 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
16813 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
16814 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
16815 TREE_CONSTANT (arg
) = 1;
16818 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
16820 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
16822 TREE_VEC_ELT (targs
, i
) = arg
;
16826 return unify_parameter_deduction_failure (explain_p
, tparm
);
16829 #ifdef ENABLE_CHECKING
16830 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
16831 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
16834 return unify_success (explain_p
);
16837 /* Subroutine of type_unification_real. Args are like the variables
16838 at the call site. ARG is an overloaded function (or template-id);
16839 we try deducing template args from each of the overloads, and if
16840 only one succeeds, we go with that. Modifies TARGS and returns
16841 true on success. */
16844 resolve_overloaded_unification (tree tparms
,
16848 unification_kind_t strict
,
16852 tree tempargs
= copy_node (targs
);
16854 tree goodfn
= NULL_TREE
;
16857 if (TREE_CODE (arg
) == ADDR_EXPR
)
16859 arg
= TREE_OPERAND (arg
, 0);
16865 if (TREE_CODE (arg
) == COMPONENT_REF
)
16866 /* Handle `&x' where `x' is some static or non-static member
16868 arg
= TREE_OPERAND (arg
, 1);
16870 if (TREE_CODE (arg
) == OFFSET_REF
)
16871 arg
= TREE_OPERAND (arg
, 1);
16873 /* Strip baselink information. */
16874 if (BASELINK_P (arg
))
16875 arg
= BASELINK_FUNCTIONS (arg
);
16877 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
16879 /* If we got some explicit template args, we need to plug them into
16880 the affected templates before we try to unify, in case the
16881 explicit args will completely resolve the templates in question. */
16884 tree expl_subargs
= TREE_OPERAND (arg
, 1);
16885 arg
= TREE_OPERAND (arg
, 0);
16887 for (; arg
; arg
= OVL_NEXT (arg
))
16889 tree fn
= OVL_CURRENT (arg
);
16890 tree subargs
, elem
;
16892 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
16895 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
16896 expl_subargs
, NULL_TREE
, tf_none
,
16897 /*require_all_args=*/true,
16898 /*use_default_args=*/true);
16899 if (subargs
!= error_mark_node
16900 && !any_dependent_template_arguments_p (subargs
))
16902 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
16903 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16904 elem
, strict
, sub_strict
, addr_p
, explain_p
)
16905 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
16914 /* If no templates (or more than one) are fully resolved by the
16915 explicit arguments, this template-id is a non-deduced context; it
16916 could still be OK if we deduce all template arguments for the
16917 enclosing call through other arguments. */
16921 else if (TREE_CODE (arg
) != OVERLOAD
16922 && TREE_CODE (arg
) != FUNCTION_DECL
)
16923 /* If ARG is, for example, "(0, &f)" then its type will be unknown
16924 -- but the deduction does not succeed because the expression is
16925 not just the function on its own. */
16928 for (; arg
; arg
= OVL_NEXT (arg
))
16929 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
16930 TREE_TYPE (OVL_CURRENT (arg
)),
16931 strict
, sub_strict
, addr_p
, explain_p
)
16932 && (!goodfn
|| !decls_match (goodfn
, OVL_CURRENT (arg
))))
16934 goodfn
= OVL_CURRENT (arg
);
16938 /* [temp.deduct.type] A template-argument can be deduced from a pointer
16939 to function or pointer to member function argument if the set of
16940 overloaded functions does not contain function templates and at most
16941 one of a set of overloaded functions provides a unique match.
16943 So if we found multiple possibilities, we return success but don't
16944 deduce anything. */
16948 int i
= TREE_VEC_LENGTH (targs
);
16950 if (TREE_VEC_ELT (tempargs
, i
))
16952 tree old
= TREE_VEC_ELT (targs
, i
);
16953 tree new_
= TREE_VEC_ELT (tempargs
, i
);
16954 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
16955 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
16956 /* Don't forget explicit template arguments in a pack. */
16957 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
16958 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
16959 TREE_VEC_ELT (targs
, i
) = new_
;
16968 /* Core DR 115: In contexts where deduction is done and fails, or in
16969 contexts where deduction is not done, if a template argument list is
16970 specified and it, along with any default template arguments, identifies
16971 a single function template specialization, then the template-id is an
16972 lvalue for the function template specialization. */
16975 resolve_nondeduced_context (tree orig_expr
)
16977 tree expr
, offset
, baselink
;
16980 if (!type_unknown_p (orig_expr
))
16985 offset
= NULL_TREE
;
16986 baselink
= NULL_TREE
;
16988 if (TREE_CODE (expr
) == ADDR_EXPR
)
16990 expr
= TREE_OPERAND (expr
, 0);
16993 if (TREE_CODE (expr
) == OFFSET_REF
)
16996 expr
= TREE_OPERAND (expr
, 1);
16998 if (BASELINK_P (expr
))
17001 expr
= BASELINK_FUNCTIONS (expr
);
17004 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
17007 tree goodfn
= NULL_TREE
;
17009 /* If we got some explicit template args, we need to plug them into
17010 the affected templates before we try to unify, in case the
17011 explicit args will completely resolve the templates in question. */
17013 tree expl_subargs
= TREE_OPERAND (expr
, 1);
17014 tree arg
= TREE_OPERAND (expr
, 0);
17015 tree badfn
= NULL_TREE
;
17016 tree badargs
= NULL_TREE
;
17018 for (; arg
; arg
= OVL_NEXT (arg
))
17020 tree fn
= OVL_CURRENT (arg
);
17021 tree subargs
, elem
;
17023 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
17026 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
17027 expl_subargs
, NULL_TREE
, tf_none
,
17028 /*require_all_args=*/true,
17029 /*use_default_args=*/true);
17030 if (subargs
!= error_mark_node
17031 && !any_dependent_template_arguments_p (subargs
))
17033 elem
= instantiate_template (fn
, subargs
, tf_none
);
17034 if (elem
== error_mark_node
)
17039 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
17048 mark_used (goodfn
);
17051 expr
= build_baselink (BASELINK_BINFO (baselink
),
17052 BASELINK_ACCESS_BINFO (baselink
),
17053 expr
, BASELINK_OPTYPE (baselink
));
17057 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
17058 expr
= build_offset_ref (base
, expr
, addr
, tf_warning_or_error
);
17061 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
17064 else if (good
== 0 && badargs
)
17065 /* There were no good options and at least one bad one, so let the
17066 user know what the problem is. */
17067 instantiate_template (badfn
, badargs
, tf_warning_or_error
);
17072 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17073 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17074 different overloads deduce different arguments for a given parm.
17075 ADDR_P is true if the expression for which deduction is being
17076 performed was of the form "& fn" rather than simply "fn".
17078 Returns 1 on success. */
17081 try_one_overload (tree tparms
,
17086 unification_kind_t strict
,
17095 if (arg
== error_mark_node
)
17098 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17099 to function or pointer to member function argument if the set of
17100 overloaded functions does not contain function templates and at most
17101 one of a set of overloaded functions provides a unique match.
17103 So if this is a template, just return success. */
17105 if (uses_template_parms (arg
))
17108 if (TREE_CODE (arg
) == METHOD_TYPE
)
17109 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
17111 arg
= build_pointer_type (arg
);
17113 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
17115 /* We don't copy orig_targs for this because if we have already deduced
17116 some template args from previous args, unify would complain when we
17117 try to deduce a template parameter for the same argument, even though
17118 there isn't really a conflict. */
17119 nargs
= TREE_VEC_LENGTH (targs
);
17120 tempargs
= make_tree_vec (nargs
);
17122 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
17125 /* First make sure we didn't deduce anything that conflicts with
17126 explicitly specified args. */
17127 for (i
= nargs
; i
--; )
17129 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17130 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
17134 else if (uses_template_parms (elt
))
17135 /* Since we're unifying against ourselves, we will fill in
17136 template args used in the function parm list with our own
17137 template parms. Discard them. */
17138 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
17139 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
17143 for (i
= nargs
; i
--; )
17145 tree elt
= TREE_VEC_ELT (tempargs
, i
);
17148 TREE_VEC_ELT (targs
, i
) = elt
;
17154 /* PARM is a template class (perhaps with unbound template
17155 parameters). ARG is a fully instantiated type. If ARG can be
17156 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17157 TARGS are as for unify. */
17160 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
17163 tree copy_of_targs
;
17165 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
17166 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
17167 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
17170 /* We need to make a new template argument vector for the call to
17171 unify. If we used TARGS, we'd clutter it up with the result of
17172 the attempted unification, even if this class didn't work out.
17173 We also don't want to commit ourselves to all the unifications
17174 we've already done, since unification is supposed to be done on
17175 an argument-by-argument basis. In other words, consider the
17176 following pathological case:
17178 template <int I, int J, int K>
17181 template <int I, int J>
17182 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17184 template <int I, int J, int K>
17185 void f(S<I, J, K>, S<I, I, I>);
17194 Now, by the time we consider the unification involving `s2', we
17195 already know that we must have `f<0, 0, 0>'. But, even though
17196 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17197 because there are two ways to unify base classes of S<0, 1, 2>
17198 with S<I, I, I>. If we kept the already deduced knowledge, we
17199 would reject the possibility I=1. */
17200 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
17202 /* If unification failed, we're done. */
17203 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
17204 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
17210 /* Given a template type PARM and a class type ARG, find the unique
17211 base type in ARG that is an instance of PARM. We do not examine
17212 ARG itself; only its base-classes. If there is not exactly one
17213 appropriate base class, return NULL_TREE. PARM may be the type of
17214 a partial specialization, as well as a plain template type. Used
17217 static enum template_base_result
17218 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
17219 bool explain_p
, tree
*result
)
17221 tree rval
= NULL_TREE
;
17224 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
17226 binfo
= TYPE_BINFO (complete_type (arg
));
17229 /* The type could not be completed. */
17230 *result
= NULL_TREE
;
17231 return tbr_incomplete_type
;
17234 /* Walk in inheritance graph order. The search order is not
17235 important, and this avoids multiple walks of virtual bases. */
17236 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
17238 tree r
= try_class_unification (tparms
, targs
, parm
,
17239 BINFO_TYPE (binfo
), explain_p
);
17243 /* If there is more than one satisfactory baseclass, then:
17247 If they yield more than one possible deduced A, the type
17251 if (rval
&& !same_type_p (r
, rval
))
17253 *result
= NULL_TREE
;
17254 return tbr_ambiguous_baseclass
;
17262 return tbr_success
;
17265 /* Returns the level of DECL, which declares a template parameter. */
17268 template_decl_level (tree decl
)
17270 switch (TREE_CODE (decl
))
17273 case TEMPLATE_DECL
:
17274 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
17277 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
17280 gcc_unreachable ();
17285 /* Decide whether ARG can be unified with PARM, considering only the
17286 cv-qualifiers of each type, given STRICT as documented for unify.
17287 Returns nonzero iff the unification is OK on that basis. */
17290 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
17292 int arg_quals
= cp_type_quals (arg
);
17293 int parm_quals
= cp_type_quals (parm
);
17295 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17296 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17298 /* Although a CVR qualifier is ignored when being applied to a
17299 substituted template parameter ([8.3.2]/1 for example), that
17300 does not allow us to unify "const T" with "int&" because both
17301 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17302 It is ok when we're allowing additional CV qualifiers
17303 at the outer level [14.8.2.1]/3,1st bullet. */
17304 if ((TREE_CODE (arg
) == REFERENCE_TYPE
17305 || TREE_CODE (arg
) == FUNCTION_TYPE
17306 || TREE_CODE (arg
) == METHOD_TYPE
)
17307 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
17310 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
17311 && (parm_quals
& TYPE_QUAL_RESTRICT
))
17315 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
17316 && (arg_quals
& parm_quals
) != parm_quals
)
17319 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
17320 && (parm_quals
& arg_quals
) != arg_quals
)
17326 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17328 template_parm_level_and_index (tree parm
, int* level
, int* index
)
17330 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17331 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17332 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17334 *index
= TEMPLATE_TYPE_IDX (parm
);
17335 *level
= TEMPLATE_TYPE_LEVEL (parm
);
17339 *index
= TEMPLATE_PARM_IDX (parm
);
17340 *level
= TEMPLATE_PARM_LEVEL (parm
);
17344 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17346 if (unify (TP, TA, P, A, S, EP)) \
17350 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17351 expansion at the end of PACKED_PARMS. Returns 0 if the type
17352 deduction succeeds, 1 otherwise. STRICT is the same as in
17353 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17354 call argument list. We'll need to adjust the arguments to make them
17355 types. SUBR tells us if this is from a recursive call to
17356 type_unification_real, or for comparing two template argument
17360 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
17361 tree packed_args
, unification_kind_t strict
,
17362 bool subr
, bool explain_p
)
17365 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
17366 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
17367 tree pack
, packs
= NULL_TREE
;
17368 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
17370 packed_args
= expand_template_argument_pack (packed_args
);
17372 int len
= TREE_VEC_LENGTH (packed_args
);
17374 /* Determine the parameter packs we will be deducing from the
17375 pattern, and record their current deductions. */
17376 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
17377 pack
; pack
= TREE_CHAIN (pack
))
17379 tree parm_pack
= TREE_VALUE (pack
);
17382 /* Determine the index and level of this parameter pack. */
17383 template_parm_level_and_index (parm_pack
, &level
, &idx
);
17385 /* Keep track of the parameter packs and their corresponding
17387 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
17388 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
17391 /* Loop through all of the arguments that have not yet been
17392 unified and unify each with the pattern. */
17393 for (i
= start
; i
< len
; i
++)
17396 bool any_explicit
= false;
17397 tree arg
= TREE_VEC_ELT (packed_args
, i
);
17399 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17400 or the element of its argument pack at the current index if
17401 this argument was explicitly specified. */
17402 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17406 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17409 if (TREE_VALUE (pack
)
17410 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
17411 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
17413 any_explicit
= true;
17414 arg
= TREE_VEC_ELT (pargs
, i
- start
);
17416 TMPL_ARG (targs
, level
, idx
) = arg
;
17419 /* If we had explicit template arguments, substitute them into the
17420 pattern before deduction. */
17423 /* Some arguments might still be unspecified or dependent. */
17425 ++processing_template_decl
;
17426 dependent
= any_dependent_template_arguments_p (targs
);
17428 --processing_template_decl
;
17429 parm
= tsubst (pattern
, targs
,
17430 explain_p
? tf_warning_or_error
: tf_none
,
17433 --processing_template_decl
;
17434 if (parm
== error_mark_node
)
17440 /* Unify the pattern with the current argument. */
17441 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
17442 LOOKUP_IMPLICIT
, explain_p
))
17445 /* For each parameter pack, collect the deduced value. */
17446 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17449 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17451 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
17452 TMPL_ARG (targs
, level
, idx
);
17456 /* Verify that the results of unification with the parameter packs
17457 produce results consistent with what we've seen before, and make
17458 the deduced argument packs available. */
17459 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
17461 tree old_pack
= TREE_VALUE (pack
);
17462 tree new_args
= TREE_TYPE (pack
);
17463 int i
, len
= TREE_VEC_LENGTH (new_args
);
17465 bool nondeduced_p
= false;
17467 /* By default keep the original deduced argument pack.
17468 If necessary, more specific code is going to update the
17469 resulting deduced argument later down in this function. */
17470 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
17471 TMPL_ARG (targs
, level
, idx
) = old_pack
;
17473 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17474 actually deduce anything. */
17475 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
17476 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
17477 nondeduced_p
= true;
17481 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
17483 /* If we had fewer function args than explicit template args,
17484 just use the explicits. */
17485 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17486 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
17487 if (len
< explicit_len
)
17488 new_args
= explicit_args
;
17494 /* Build the deduced *_ARGUMENT_PACK. */
17495 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
17497 result
= make_node (NONTYPE_ARGUMENT_PACK
);
17498 TREE_TYPE (result
) =
17499 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
17500 TREE_CONSTANT (result
) = 1;
17503 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
17505 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
17507 /* Note the deduced argument packs for this parameter
17509 TMPL_ARG (targs
, level
, idx
) = result
;
17511 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
17512 && (ARGUMENT_PACK_ARGS (old_pack
)
17513 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
17515 /* We only had the explicitly-provided arguments before, but
17516 now we have a complete set of arguments. */
17517 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
17519 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
17520 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
17521 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
17525 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
17526 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
17528 if (!comp_template_args_with_info (old_args
, new_args
,
17529 &bad_old_arg
, &bad_new_arg
))
17530 /* Inconsistent unification of this parameter pack. */
17531 return unify_parameter_pack_inconsistent (explain_p
,
17537 return unify_success (explain_p
);
17540 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17541 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17542 parameters and return value are as for unify. */
17545 unify_array_domain (tree tparms
, tree targs
,
17546 tree parm_dom
, tree arg_dom
,
17554 /* Our representation of array types uses "N - 1" as the
17555 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17556 not an integer constant. We cannot unify arbitrarily
17557 complex expressions, so we eliminate the MINUS_EXPRs
17559 parm_max
= TYPE_MAX_VALUE (parm_dom
);
17560 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
17563 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
17564 parm_max
= TREE_OPERAND (parm_max
, 0);
17566 arg_max
= TYPE_MAX_VALUE (arg_dom
);
17567 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
17570 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17571 trying to unify the type of a variable with the type
17572 of a template parameter. For example:
17574 template <unsigned int N>
17575 void f (char (&) [N]);
17582 Here, the type of the ARG will be "int [g(i)]", and
17583 may be a SAVE_EXPR, etc. */
17584 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
17585 return unify_vla_arg (explain_p
, arg_dom
);
17586 arg_max
= TREE_OPERAND (arg_max
, 0);
17589 /* If only one of the bounds used a MINUS_EXPR, compensate
17590 by adding one to the other bound. */
17591 if (parm_cst
&& !arg_cst
)
17592 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17596 else if (arg_cst
&& !parm_cst
)
17597 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
17602 return unify (tparms
, targs
, parm_max
, arg_max
,
17603 UNIFY_ALLOW_INTEGER
, explain_p
);
17606 /* Deduce the value of template parameters. TPARMS is the (innermost)
17607 set of template parameters to a template. TARGS is the bindings
17608 for those template parameters, as determined thus far; TARGS may
17609 include template arguments for outer levels of template parameters
17610 as well. PARM is a parameter to a template function, or a
17611 subcomponent of that parameter; ARG is the corresponding argument.
17612 This function attempts to match PARM with ARG in a manner
17613 consistent with the existing assignments in TARGS. If more values
17614 are deduced, then TARGS is updated.
17616 Returns 0 if the type deduction succeeds, 1 otherwise. The
17617 parameter STRICT is a bitwise or of the following flags:
17620 Require an exact match between PARM and ARG.
17621 UNIFY_ALLOW_MORE_CV_QUAL:
17622 Allow the deduced ARG to be more cv-qualified (by qualification
17623 conversion) than ARG.
17624 UNIFY_ALLOW_LESS_CV_QUAL:
17625 Allow the deduced ARG to be less cv-qualified than ARG.
17626 UNIFY_ALLOW_DERIVED:
17627 Allow the deduced ARG to be a template base class of ARG,
17628 or a pointer to a template base class of the type pointed to by
17630 UNIFY_ALLOW_INTEGER:
17631 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17632 case for more information.
17633 UNIFY_ALLOW_OUTER_LEVEL:
17634 This is the outermost level of a deduction. Used to determine validity
17635 of qualification conversions. A valid qualification conversion must
17636 have const qualified pointers leading up to the inner type which
17637 requires additional CV quals, except at the outer level, where const
17638 is not required [conv.qual]. It would be normal to set this flag in
17639 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17640 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17641 This is the outermost level of a deduction, and PARM can be more CV
17642 qualified at this point.
17643 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17644 This is the outermost level of a deduction, and PARM can be less CV
17645 qualified at this point. */
17648 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
17654 int strict_in
= strict
;
17656 /* I don't think this will do the right thing with respect to types.
17657 But the only case I've seen it in so far has been array bounds, where
17658 signedness is the only information lost, and I think that will be
17660 while (TREE_CODE (parm
) == NOP_EXPR
)
17661 parm
= TREE_OPERAND (parm
, 0);
17663 if (arg
== error_mark_node
)
17664 return unify_invalid (explain_p
);
17665 if (arg
== unknown_type_node
17666 || arg
== init_list_type_node
)
17667 /* We can't deduce anything from this, but we might get all the
17668 template args from other function args. */
17669 return unify_success (explain_p
);
17671 /* If PARM uses template parameters, then we can't bail out here,
17672 even if ARG == PARM, since we won't record unifications for the
17673 template parameters. We might need them if we're trying to
17674 figure out which of two things is more specialized. */
17675 if (arg
== parm
&& !uses_template_parms (parm
))
17676 return unify_success (explain_p
);
17678 /* Handle init lists early, so the rest of the function can assume
17679 we're dealing with a type. */
17680 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
17684 tree orig_parm
= parm
;
17686 /* Replace T with std::initializer_list<T> for deduction. */
17687 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17688 && flag_deduce_init_list
)
17689 parm
= listify (parm
);
17691 if (!is_std_init_list (parm
)
17692 && TREE_CODE (parm
) != ARRAY_TYPE
)
17693 /* We can only deduce from an initializer list argument if the
17694 parameter is std::initializer_list or an array; otherwise this
17695 is a non-deduced context. */
17696 return unify_success (explain_p
);
17698 if (TREE_CODE (parm
) == ARRAY_TYPE
)
17699 elttype
= TREE_TYPE (parm
);
17701 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
17703 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
17705 int elt_strict
= strict
;
17707 if (elt
== error_mark_node
)
17708 return unify_invalid (explain_p
);
17710 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
17712 tree type
= TREE_TYPE (elt
);
17713 /* It should only be possible to get here for a call. */
17714 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
17715 elt_strict
|= maybe_adjust_types_for_deduction
17716 (DEDUCE_CALL
, &elttype
, &type
, elt
);
17720 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
17724 if (TREE_CODE (parm
) == ARRAY_TYPE
17725 && deducible_array_bound (TYPE_DOMAIN (parm
)))
17727 /* Also deduce from the length of the initializer list. */
17728 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
17729 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
17730 if (idx
== error_mark_node
)
17731 return unify_invalid (explain_p
);
17732 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
17736 /* If the std::initializer_list<T> deduction worked, replace the
17737 deduced A with std::initializer_list<A>. */
17738 if (orig_parm
!= parm
)
17740 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
17741 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17742 targ
= listify (targ
);
17743 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
17745 return unify_success (explain_p
);
17748 /* Immediately reject some pairs that won't unify because of
17749 cv-qualification mismatches. */
17750 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17752 /* It is the elements of the array which hold the cv quals of an array
17753 type, and the elements might be template type parms. We'll check
17754 when we recurse. */
17755 && TREE_CODE (arg
) != ARRAY_TYPE
17756 /* We check the cv-qualifiers when unifying with template type
17757 parameters below. We want to allow ARG `const T' to unify with
17758 PARM `T' for example, when computing which of two templates
17759 is more specialized, for example. */
17760 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
17761 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
17762 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17764 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
17765 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
17766 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
17767 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
17768 strict
&= ~UNIFY_ALLOW_DERIVED
;
17769 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
17770 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
17772 switch (TREE_CODE (parm
))
17774 case TYPENAME_TYPE
:
17776 case UNBOUND_CLASS_TEMPLATE
:
17777 /* In a type which contains a nested-name-specifier, template
17778 argument values cannot be deduced for template parameters used
17779 within the nested-name-specifier. */
17780 return unify_success (explain_p
);
17782 case TEMPLATE_TYPE_PARM
:
17783 case TEMPLATE_TEMPLATE_PARM
:
17784 case BOUND_TEMPLATE_TEMPLATE_PARM
:
17785 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17786 if (error_operand_p (tparm
))
17787 return unify_invalid (explain_p
);
17789 if (TEMPLATE_TYPE_LEVEL (parm
)
17790 != template_decl_level (tparm
))
17791 /* The PARM is not one we're trying to unify. Just check
17792 to see if it matches ARG. */
17794 if (TREE_CODE (arg
) == TREE_CODE (parm
)
17795 && (is_auto (parm
) ? is_auto (arg
)
17796 : same_type_p (parm
, arg
)))
17797 return unify_success (explain_p
);
17799 return unify_type_mismatch (explain_p
, parm
, arg
);
17801 idx
= TEMPLATE_TYPE_IDX (parm
);
17802 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
17803 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
17804 if (error_operand_p (tparm
))
17805 return unify_invalid (explain_p
);
17807 /* Check for mixed types and values. */
17808 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
17809 && TREE_CODE (tparm
) != TYPE_DECL
)
17810 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17811 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
17812 gcc_unreachable ();
17814 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17816 /* ARG must be constructed from a template class or a template
17817 template parameter. */
17818 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
17819 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
17820 return unify_template_deduction_failure (explain_p
, parm
, arg
);
17822 tree parmvec
= TYPE_TI_ARGS (parm
);
17823 /* An alias template name is never deduced. */
17824 if (TYPE_ALIAS_P (arg
))
17825 arg
= strip_typedefs (arg
);
17826 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
17827 tree full_argvec
= add_to_template_args (targs
, argvec
);
17829 = DECL_INNERMOST_TEMPLATE_PARMS
17830 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
17832 int parm_variadic_p
= 0;
17834 /* The resolution to DR150 makes clear that default
17835 arguments for an N-argument may not be used to bind T
17836 to a template template parameter with fewer than N
17837 parameters. It is not safe to permit the binding of
17838 default arguments as an extension, as that may change
17839 the meaning of a conforming program. Consider:
17841 struct Dense { static const unsigned int dim = 1; };
17843 template <template <typename> class View,
17845 void operator+(float, View<Block> const&);
17847 template <typename Block,
17848 unsigned int Dim = Block::dim>
17849 struct Lvalue_proxy { operator float() const; };
17853 Lvalue_proxy<Dense> p;
17858 Here, if Lvalue_proxy is permitted to bind to View, then
17859 the global operator+ will be used; if they are not, the
17860 Lvalue_proxy will be converted to float. */
17861 if (coerce_template_parms (parm_parms
,
17863 TYPE_TI_TEMPLATE (parm
),
17865 ? tf_warning_or_error
17867 /*require_all_args=*/true,
17868 /*use_default_args=*/false)
17869 == error_mark_node
)
17872 /* Deduce arguments T, i from TT<T> or TT<i>.
17873 We check each element of PARMVEC and ARGVEC individually
17874 rather than the whole TREE_VEC since they can have
17875 different number of elements. */
17877 parmvec
= expand_template_argument_pack (parmvec
);
17878 argvec
= expand_template_argument_pack (argvec
);
17880 len
= TREE_VEC_LENGTH (parmvec
);
17882 /* Check if the parameters end in a pack, making them
17885 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
17886 parm_variadic_p
= 1;
17888 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17889 /* If the template argument list of P contains a pack
17890 expansion that is not the last template argument, the
17891 entire template argument list is a non-deduced
17893 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
17894 return unify_success (explain_p
);
17896 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
17897 return unify_too_few_arguments (explain_p
,
17898 TREE_VEC_LENGTH (argvec
), len
);
17900 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
17902 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
17903 TREE_VEC_ELT (parmvec
, i
),
17904 TREE_VEC_ELT (argvec
, i
),
17905 UNIFY_ALLOW_NONE
, explain_p
);
17908 if (parm_variadic_p
17909 && unify_pack_expansion (tparms
, targs
,
17912 /*subr=*/true, explain_p
))
17915 arg
= TYPE_TI_TEMPLATE (arg
);
17917 /* Fall through to deduce template name. */
17920 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
17921 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
17923 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
17925 /* Simple cases: Value already set, does match or doesn't. */
17926 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
17927 return unify_success (explain_p
);
17929 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17933 /* If PARM is `const T' and ARG is only `int', we don't have
17934 a match unless we are allowing additional qualification.
17935 If ARG is `const int' and PARM is just `T' that's OK;
17936 that binds `const int' to `T'. */
17937 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
17939 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
17941 /* Consider the case where ARG is `const volatile int' and
17942 PARM is `const T'. Then, T should be `volatile int'. */
17943 arg
= cp_build_qualified_type_real
17944 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
17945 if (arg
== error_mark_node
)
17946 return unify_invalid (explain_p
);
17948 /* Simple cases: Value already set, does match or doesn't. */
17949 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
17950 return unify_success (explain_p
);
17952 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
17954 /* Make sure that ARG is not a variable-sized array. (Note
17955 that were talking about variable-sized arrays (like
17956 `int[n]'), rather than arrays of unknown size (like
17957 `int[]').) We'll get very confused by such a type since
17958 the bound of the array is not constant, and therefore
17959 not mangleable. Besides, such types are not allowed in
17960 ISO C++, so we can do as we please here. We do allow
17961 them for 'auto' deduction, since that isn't ABI-exposed. */
17962 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
17963 return unify_vla_arg (explain_p
, arg
);
17965 /* Strip typedefs as in convert_template_argument. */
17966 arg
= canonicalize_type_argument (arg
, tf_none
);
17969 /* If ARG is a parameter pack or an expansion, we cannot unify
17970 against it unless PARM is also a parameter pack. */
17971 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
17972 && !template_parameter_pack_p (parm
))
17973 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
17975 /* If the argument deduction results is a METHOD_TYPE,
17976 then there is a problem.
17977 METHOD_TYPE doesn't map to any real C++ type the result of
17978 the deduction can not be of that type. */
17979 if (TREE_CODE (arg
) == METHOD_TYPE
)
17980 return unify_method_type_error (explain_p
, arg
);
17982 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
17983 return unify_success (explain_p
);
17985 case TEMPLATE_PARM_INDEX
:
17986 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
17987 if (error_operand_p (tparm
))
17988 return unify_invalid (explain_p
);
17990 if (TEMPLATE_PARM_LEVEL (parm
)
17991 != template_decl_level (tparm
))
17993 /* The PARM is not one we're trying to unify. Just check
17994 to see if it matches ARG. */
17995 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
17996 && cp_tree_equal (parm
, arg
));
17998 unify_expression_unequal (explain_p
, parm
, arg
);
18002 idx
= TEMPLATE_PARM_IDX (parm
);
18003 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
18007 int x
= !cp_tree_equal (targ
, arg
);
18009 unify_inconsistency (explain_p
, parm
, targ
, arg
);
18013 /* [temp.deduct.type] If, in the declaration of a function template
18014 with a non-type template-parameter, the non-type
18015 template-parameter is used in an expression in the function
18016 parameter-list and, if the corresponding template-argument is
18017 deduced, the template-argument type shall match the type of the
18018 template-parameter exactly, except that a template-argument
18019 deduced from an array bound may be of any integral type.
18020 The non-type parameter might use already deduced type parameters. */
18021 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
18022 if (!TREE_TYPE (arg
))
18023 /* Template-parameter dependent expression. Just accept it for now.
18024 It will later be processed in convert_template_argument. */
18026 else if (same_type_p (TREE_TYPE (arg
), tparm
))
18028 else if ((strict
& UNIFY_ALLOW_INTEGER
)
18029 && CP_INTEGRAL_TYPE_P (tparm
))
18030 /* Convert the ARG to the type of PARM; the deduced non-type
18031 template argument must exactly match the types of the
18032 corresponding parameter. */
18033 arg
= fold (build_nop (tparm
, arg
));
18034 else if (uses_template_parms (tparm
))
18035 /* We haven't deduced the type of this parameter yet. Try again
18037 return unify_success (explain_p
);
18039 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
18041 /* If ARG is a parameter pack or an expansion, we cannot unify
18042 against it unless PARM is also a parameter pack. */
18043 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
18044 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
18045 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
18047 arg
= strip_typedefs_expr (arg
);
18048 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
18049 return unify_success (explain_p
);
18053 /* A pointer-to-member constant can be unified only with
18054 another constant. */
18055 if (TREE_CODE (arg
) != PTRMEM_CST
)
18056 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
18058 /* Just unify the class member. It would be useless (and possibly
18059 wrong, depending on the strict flags) to unify also
18060 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18061 arg refer to the same variable, even if through different
18062 classes. For instance:
18064 struct A { int x; };
18067 Unification of &A::x and &B::x must succeed. */
18068 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
18069 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
18074 if (!TYPE_PTR_P (arg
))
18075 return unify_type_mismatch (explain_p
, parm
, arg
);
18077 /* [temp.deduct.call]
18079 A can be another pointer or pointer to member type that can
18080 be converted to the deduced A via a qualification
18081 conversion (_conv.qual_).
18083 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18084 This will allow for additional cv-qualification of the
18085 pointed-to types if appropriate. */
18087 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
18088 /* The derived-to-base conversion only persists through one
18089 level of pointers. */
18090 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
18092 return unify (tparms
, targs
, TREE_TYPE (parm
),
18093 TREE_TYPE (arg
), strict
, explain_p
);
18096 case REFERENCE_TYPE
:
18097 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
18098 return unify_type_mismatch (explain_p
, parm
, arg
);
18099 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18100 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18103 if (TREE_CODE (arg
) != ARRAY_TYPE
)
18104 return unify_type_mismatch (explain_p
, parm
, arg
);
18105 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
18106 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
18107 return unify_type_mismatch (explain_p
, parm
, arg
);
18108 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18109 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
18110 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
18111 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
18112 TYPE_DOMAIN (arg
), explain_p
);
18113 return unify_success (explain_p
);
18120 case ENUMERAL_TYPE
:
18123 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18124 return unify_type_mismatch (explain_p
, parm
, arg
);
18126 /* We have already checked cv-qualification at the top of the
18128 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
18129 return unify_type_mismatch (explain_p
, parm
, arg
);
18131 /* As far as unification is concerned, this wins. Later checks
18132 will invalidate it if necessary. */
18133 return unify_success (explain_p
);
18135 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18136 /* Type INTEGER_CST can come from ordinary constant template args. */
18138 while (TREE_CODE (arg
) == NOP_EXPR
)
18139 arg
= TREE_OPERAND (arg
, 0);
18141 if (TREE_CODE (arg
) != INTEGER_CST
)
18142 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18143 return (tree_int_cst_equal (parm
, arg
)
18144 ? unify_success (explain_p
)
18145 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
18149 int i
, len
, argslen
;
18150 int parm_variadic_p
= 0;
18152 if (TREE_CODE (arg
) != TREE_VEC
)
18153 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18155 len
= TREE_VEC_LENGTH (parm
);
18156 argslen
= TREE_VEC_LENGTH (arg
);
18158 /* Check for pack expansions in the parameters. */
18159 for (i
= 0; i
< len
; ++i
)
18161 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
18164 /* We can unify against something with a trailing
18166 parm_variadic_p
= 1;
18168 /* [temp.deduct.type]/9: If the template argument list of
18169 P contains a pack expansion that is not the last
18170 template argument, the entire template argument list
18171 is a non-deduced context. */
18172 return unify_success (explain_p
);
18176 /* If we don't have enough arguments to satisfy the parameters
18177 (not counting the pack expression at the end), or we have
18178 too many arguments for a parameter list that doesn't end in
18179 a pack expression, we can't unify. */
18180 if (parm_variadic_p
18181 ? argslen
< len
- parm_variadic_p
18183 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
18185 /* Unify all of the parameters that precede the (optional)
18186 pack expression. */
18187 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
18189 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
18190 TREE_VEC_ELT (parm
, i
),
18191 TREE_VEC_ELT (arg
, i
),
18192 UNIFY_ALLOW_NONE
, explain_p
);
18194 if (parm_variadic_p
)
18195 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
18197 /*subr=*/true, explain_p
);
18198 return unify_success (explain_p
);
18203 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18204 return unify_type_mismatch (explain_p
, parm
, arg
);
18206 if (TYPE_PTRMEMFUNC_P (parm
))
18208 if (!TYPE_PTRMEMFUNC_P (arg
))
18209 return unify_type_mismatch (explain_p
, parm
, arg
);
18211 return unify (tparms
, targs
,
18212 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
18213 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
18214 strict
, explain_p
);
18216 else if (TYPE_PTRMEMFUNC_P (arg
))
18217 return unify_type_mismatch (explain_p
, parm
, arg
);
18219 if (CLASSTYPE_TEMPLATE_INFO (parm
))
18221 tree t
= NULL_TREE
;
18223 if (strict_in
& UNIFY_ALLOW_DERIVED
)
18225 /* First, we try to unify the PARM and ARG directly. */
18226 t
= try_class_unification (tparms
, targs
,
18227 parm
, arg
, explain_p
);
18231 /* Fallback to the special case allowed in
18232 [temp.deduct.call]:
18234 If P is a class, and P has the form
18235 template-id, then A can be a derived class of
18236 the deduced A. Likewise, if P is a pointer to
18237 a class of the form template-id, A can be a
18238 pointer to a derived class pointed to by the
18240 enum template_base_result r
;
18241 r
= get_template_base (tparms
, targs
, parm
, arg
,
18245 return unify_no_common_base (explain_p
, r
, parm
, arg
);
18248 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
18249 && (CLASSTYPE_TI_TEMPLATE (parm
)
18250 == CLASSTYPE_TI_TEMPLATE (arg
)))
18251 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18252 Then, we should unify `int' and `U'. */
18255 /* There's no chance of unification succeeding. */
18256 return unify_type_mismatch (explain_p
, parm
, arg
);
18258 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
18259 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
18261 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
18262 return unify_type_mismatch (explain_p
, parm
, arg
);
18263 return unify_success (explain_p
);
18266 case FUNCTION_TYPE
:
18268 unsigned int nargs
;
18273 if (TREE_CODE (arg
) != TREE_CODE (parm
))
18274 return unify_type_mismatch (explain_p
, parm
, arg
);
18276 /* CV qualifications for methods can never be deduced, they must
18277 match exactly. We need to check them explicitly here,
18278 because type_unification_real treats them as any other
18279 cv-qualified parameter. */
18280 if (TREE_CODE (parm
) == METHOD_TYPE
18281 && (!check_cv_quals_for_unify
18283 class_of_this_parm (arg
),
18284 class_of_this_parm (parm
))))
18285 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18287 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
18288 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
18290 nargs
= list_length (TYPE_ARG_TYPES (arg
));
18291 args
= XALLOCAVEC (tree
, nargs
);
18292 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
18293 a
!= NULL_TREE
&& a
!= void_list_node
;
18294 a
= TREE_CHAIN (a
), ++i
)
18295 args
[i
] = TREE_VALUE (a
);
18298 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
18299 args
, nargs
, 1, DEDUCE_EXACT
,
18300 LOOKUP_NORMAL
, NULL
, explain_p
);
18304 /* Unify a pointer to member with a pointer to member function, which
18305 deduces the type of the member as a function type. */
18306 if (TYPE_PTRMEMFUNC_P (arg
))
18308 /* Check top-level cv qualifiers */
18309 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
18310 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
18312 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18313 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
18314 UNIFY_ALLOW_NONE
, explain_p
);
18316 /* Determine the type of the function we are unifying against. */
18317 tree fntype
= static_fn_type (arg
);
18319 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
18322 if (TREE_CODE (arg
) != OFFSET_TYPE
)
18323 return unify_type_mismatch (explain_p
, parm
, arg
);
18324 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
18325 TYPE_OFFSET_BASETYPE (arg
),
18326 UNIFY_ALLOW_NONE
, explain_p
);
18327 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
18328 strict
, explain_p
);
18331 if (DECL_TEMPLATE_PARM_P (parm
))
18332 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
18333 if (arg
!= integral_constant_value (parm
))
18334 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18335 return unify_success (explain_p
);
18338 case TEMPLATE_DECL
:
18339 /* Matched cases are handled by the ARG == PARM test above. */
18340 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
18343 /* A non-type template parameter that is a variable should be a
18344 an integral constant, in which case, it whould have been
18345 folded into its (constant) value. So we should not be getting
18346 a variable here. */
18347 gcc_unreachable ();
18349 case TYPE_ARGUMENT_PACK
:
18350 case NONTYPE_ARGUMENT_PACK
:
18351 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
18352 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
18355 case DECLTYPE_TYPE
:
18356 case UNDERLYING_TYPE
:
18357 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18358 or UNDERLYING_TYPE nodes. */
18359 return unify_success (explain_p
);
18362 /* Unification fails if we hit an error node. */
18363 return unify_invalid (explain_p
);
18366 if (REFERENCE_REF_P (parm
))
18367 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
18368 strict
, explain_p
);
18372 /* An unresolved overload is a nondeduced context. */
18373 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
18374 return unify_success (explain_p
);
18375 gcc_assert (EXPR_P (parm
));
18377 /* We must be looking at an expression. This can happen with
18381 void foo(S<I>, S<I + 2>);
18383 This is a "nondeduced context":
18387 The nondeduced contexts are:
18389 --A type that is a template-id in which one or more of
18390 the template-arguments is an expression that references
18391 a template-parameter.
18393 In these cases, we assume deduction succeeded, but don't
18394 actually infer any unifications. */
18396 if (!uses_template_parms (parm
)
18397 && !template_args_equal (parm
, arg
))
18398 return unify_expression_unequal (explain_p
, parm
, arg
);
18400 return unify_success (explain_p
);
18403 #undef RECUR_AND_CHECK_FAILURE
18405 /* Note that DECL can be defined in this translation unit, if
18409 mark_definable (tree decl
)
18412 DECL_NOT_REALLY_EXTERN (decl
) = 1;
18413 FOR_EACH_CLONE (clone
, decl
)
18414 DECL_NOT_REALLY_EXTERN (clone
) = 1;
18417 /* Called if RESULT is explicitly instantiated, or is a member of an
18418 explicitly instantiated class. */
18421 mark_decl_instantiated (tree result
, int extern_p
)
18423 SET_DECL_EXPLICIT_INSTANTIATION (result
);
18425 /* If this entity has already been written out, it's too late to
18426 make any modifications. */
18427 if (TREE_ASM_WRITTEN (result
))
18430 /* For anonymous namespace we don't need to do anything. */
18431 if (decl_anon_ns_mem_p (result
))
18433 gcc_assert (!TREE_PUBLIC (result
));
18437 if (TREE_CODE (result
) != FUNCTION_DECL
)
18438 /* The TREE_PUBLIC flag for function declarations will have been
18439 set correctly by tsubst. */
18440 TREE_PUBLIC (result
) = 1;
18442 /* This might have been set by an earlier implicit instantiation. */
18443 DECL_COMDAT (result
) = 0;
18446 DECL_NOT_REALLY_EXTERN (result
) = 0;
18449 mark_definable (result
);
18450 mark_needed (result
);
18451 /* Always make artificials weak. */
18452 if (DECL_ARTIFICIAL (result
) && flag_weak
)
18453 comdat_linkage (result
);
18454 /* For WIN32 we also want to put explicit instantiations in
18455 linkonce sections. */
18456 else if (TREE_PUBLIC (result
))
18457 maybe_make_one_only (result
);
18460 /* If EXTERN_P, then this function will not be emitted -- unless
18461 followed by an explicit instantiation, at which point its linkage
18462 will be adjusted. If !EXTERN_P, then this function will be
18463 emitted here. In neither circumstance do we want
18464 import_export_decl to adjust the linkage. */
18465 DECL_INTERFACE_KNOWN (result
) = 1;
18468 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18469 important template arguments. If any are missing, we check whether
18470 they're important by using error_mark_node for substituting into any
18471 args that were used for partial ordering (the ones between ARGS and END)
18472 and seeing if it bubbles up. */
18475 check_undeduced_parms (tree targs
, tree args
, tree end
)
18477 bool found
= false;
18479 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
18480 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
18483 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
18487 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
18488 if (substed
== error_mark_node
)
18494 /* Given two function templates PAT1 and PAT2, return:
18496 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18497 -1 if PAT2 is more specialized than PAT1.
18498 0 if neither is more specialized.
18500 LEN indicates the number of parameters we should consider
18501 (defaulted parameters should not be considered).
18503 The 1998 std underspecified function template partial ordering, and
18504 DR214 addresses the issue. We take pairs of arguments, one from
18505 each of the templates, and deduce them against each other. One of
18506 the templates will be more specialized if all the *other*
18507 template's arguments deduce against its arguments and at least one
18508 of its arguments *does* *not* deduce against the other template's
18509 corresponding argument. Deduction is done as for class templates.
18510 The arguments used in deduction have reference and top level cv
18511 qualifiers removed. Iff both arguments were originally reference
18512 types *and* deduction succeeds in both directions, an lvalue reference
18513 wins against an rvalue reference and otherwise the template
18514 with the more cv-qualified argument wins for that pairing (if
18515 neither is more cv-qualified, they both are equal). Unlike regular
18516 deduction, after all the arguments have been deduced in this way,
18517 we do *not* verify the deduced template argument values can be
18518 substituted into non-deduced contexts.
18520 The logic can be a bit confusing here, because we look at deduce1 and
18521 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18522 can find template arguments for pat1 to make arg1 look like arg2, that
18523 means that arg2 is at least as specialized as arg1. */
18526 more_specialized_fn (tree pat1
, tree pat2
, int len
)
18528 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
18529 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
18530 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
18531 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
18532 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
18533 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
18534 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
18535 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
18536 tree origs1
, origs2
;
18537 bool lose1
= false;
18538 bool lose2
= false;
18540 /* Remove the this parameter from non-static member functions. If
18541 one is a non-static member function and the other is not a static
18542 member function, remove the first parameter from that function
18543 also. This situation occurs for operator functions where we
18544 locate both a member function (with this pointer) and non-member
18545 operator (with explicit first operand). */
18546 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
18548 len
--; /* LEN is the number of significant arguments for DECL1 */
18549 args1
= TREE_CHAIN (args1
);
18550 if (!DECL_STATIC_FUNCTION_P (decl2
))
18551 args2
= TREE_CHAIN (args2
);
18553 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
18555 args2
= TREE_CHAIN (args2
);
18556 if (!DECL_STATIC_FUNCTION_P (decl1
))
18559 args1
= TREE_CHAIN (args1
);
18563 /* If only one is a conversion operator, they are unordered. */
18564 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
18567 /* Consider the return type for a conversion function */
18568 if (DECL_CONV_FN_P (decl1
))
18570 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
18571 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
18575 processing_template_decl
++;
18581 /* Stop when an ellipsis is seen. */
18582 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
18584 tree arg1
= TREE_VALUE (args1
);
18585 tree arg2
= TREE_VALUE (args2
);
18586 int deduce1
, deduce2
;
18592 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18593 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18595 /* When both arguments are pack expansions, we need only
18596 unify the patterns themselves. */
18597 arg1
= PACK_EXPANSION_PATTERN (arg1
);
18598 arg2
= PACK_EXPANSION_PATTERN (arg2
);
18600 /* This is the last comparison we need to do. */
18604 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
18606 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
18607 arg1
= TREE_TYPE (arg1
);
18608 quals1
= cp_type_quals (arg1
);
18611 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
18613 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
18614 arg2
= TREE_TYPE (arg2
);
18615 quals2
= cp_type_quals (arg2
);
18618 arg1
= TYPE_MAIN_VARIANT (arg1
);
18619 arg2
= TYPE_MAIN_VARIANT (arg2
);
18621 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
18623 int i
, len2
= list_length (args2
);
18624 tree parmvec
= make_tree_vec (1);
18625 tree argvec
= make_tree_vec (len2
);
18628 /* Setup the parameter vector, which contains only ARG1. */
18629 TREE_VEC_ELT (parmvec
, 0) = arg1
;
18631 /* Setup the argument vector, which contains the remaining
18633 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
18634 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18636 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
18637 argvec
, DEDUCE_EXACT
,
18638 /*subr=*/true, /*explain_p=*/false)
18641 /* We cannot deduce in the other direction, because ARG1 is
18642 a pack expansion but ARG2 is not. */
18645 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18647 int i
, len1
= list_length (args1
);
18648 tree parmvec
= make_tree_vec (1);
18649 tree argvec
= make_tree_vec (len1
);
18652 /* Setup the parameter vector, which contains only ARG1. */
18653 TREE_VEC_ELT (parmvec
, 0) = arg2
;
18655 /* Setup the argument vector, which contains the remaining
18657 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
18658 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
18660 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
18661 argvec
, DEDUCE_EXACT
,
18662 /*subr=*/true, /*explain_p=*/false)
18665 /* We cannot deduce in the other direction, because ARG2 is
18666 a pack expansion but ARG1 is not.*/
18672 /* The normal case, where neither argument is a pack
18674 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
18675 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18677 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
18678 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
18682 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18683 arg2, then arg2 is not as specialized as arg1. */
18689 /* "If, for a given type, deduction succeeds in both directions
18690 (i.e., the types are identical after the transformations above)
18691 and both P and A were reference types (before being replaced with
18692 the type referred to above):
18693 - if the type from the argument template was an lvalue reference and
18694 the type from the parameter template was not, the argument type is
18695 considered to be more specialized than the other; otherwise,
18696 - if the type from the argument template is more cv-qualified
18697 than the type from the parameter template (as described above),
18698 the argument type is considered to be more specialized than the other;
18700 - neither type is more specialized than the other." */
18702 if (deduce1
&& deduce2
)
18704 if (ref1
&& ref2
&& ref1
!= ref2
)
18711 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
18713 if ((quals1
& quals2
) == quals2
)
18715 if ((quals1
& quals2
) == quals1
)
18720 if (lose1
&& lose2
)
18721 /* We've failed to deduce something in either direction.
18722 These must be unordered. */
18725 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
18726 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
18727 /* We have already processed all of the arguments in our
18728 handing of the pack expansion type. */
18731 args1
= TREE_CHAIN (args1
);
18732 args2
= TREE_CHAIN (args2
);
18735 /* "In most cases, all template parameters must have values in order for
18736 deduction to succeed, but for partial ordering purposes a template
18737 parameter may remain without a value provided it is not used in the
18738 types being used for partial ordering."
18740 Thus, if we are missing any of the targs1 we need to substitute into
18741 origs1, then pat2 is not as specialized as pat1. This can happen when
18742 there is a nondeduced context. */
18743 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
18745 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
18748 processing_template_decl
--;
18750 /* All things being equal, if the next argument is a pack expansion
18751 for one function but not for the other, prefer the
18752 non-variadic function. FIXME this is bogus; see c++/41958. */
18754 && args1
&& TREE_VALUE (args1
)
18755 && args2
&& TREE_VALUE (args2
))
18757 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
18758 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
18761 if (lose1
== lose2
)
18769 /* Determine which of two partial specializations of TMPL is more
18772 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
18773 to the first partial specialization. The TREE_VALUE is the
18774 innermost set of template parameters for the partial
18775 specialization. PAT2 is similar, but for the second template.
18777 Return 1 if the first partial specialization is more specialized;
18778 -1 if the second is more specialized; 0 if neither is more
18781 See [temp.class.order] for information about determining which of
18782 two templates is more specialized. */
18785 more_specialized_class (tree tmpl
, tree pat1
, tree pat2
)
18790 bool any_deductions
= false;
18792 tmpl1
= TREE_TYPE (pat1
);
18793 tmpl2
= TREE_TYPE (pat2
);
18795 /* Just like what happens for functions, if we are ordering between
18796 different class template specializations, we may encounter dependent
18797 types in the arguments, and we need our dependency check functions
18798 to behave correctly. */
18799 ++processing_template_decl
;
18800 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat1
),
18801 CLASSTYPE_TI_ARGS (tmpl1
),
18802 CLASSTYPE_TI_ARGS (tmpl2
));
18806 any_deductions
= true;
18809 targs
= get_class_bindings (tmpl
, TREE_VALUE (pat2
),
18810 CLASSTYPE_TI_ARGS (tmpl2
),
18811 CLASSTYPE_TI_ARGS (tmpl1
));
18815 any_deductions
= true;
18817 --processing_template_decl
;
18819 /* In the case of a tie where at least one of the class templates
18820 has a parameter pack at the end, the template with the most
18821 non-packed parameters wins. */
18824 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
18825 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
18827 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
18828 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
18829 int len1
= TREE_VEC_LENGTH (args1
);
18830 int len2
= TREE_VEC_LENGTH (args2
);
18832 /* We don't count the pack expansion at the end. */
18833 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
18835 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
18840 else if (len1
< len2
)
18847 /* Return the template arguments that will produce the function signature
18848 DECL from the function template FN, with the explicit template
18849 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
18850 also match. Return NULL_TREE if no satisfactory arguments could be
18854 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
18856 int ntparms
= DECL_NTPARMS (fn
);
18857 tree targs
= make_tree_vec (ntparms
);
18858 tree decl_type
= TREE_TYPE (decl
);
18859 tree decl_arg_types
;
18861 unsigned int nargs
, ix
;
18864 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
18866 /* Never do unification on the 'this' parameter. */
18867 decl_arg_types
= skip_artificial_parms_for (decl
,
18868 TYPE_ARG_TYPES (decl_type
));
18870 nargs
= list_length (decl_arg_types
);
18871 args
= XALLOCAVEC (tree
, nargs
);
18872 for (arg
= decl_arg_types
, ix
= 0;
18873 arg
!= NULL_TREE
&& arg
!= void_list_node
;
18874 arg
= TREE_CHAIN (arg
), ++ix
)
18875 args
[ix
] = TREE_VALUE (arg
);
18877 if (fn_type_unification (fn
, explicit_args
, targs
,
18879 (check_rettype
|| DECL_CONV_FN_P (fn
)
18880 ? TREE_TYPE (decl_type
) : NULL_TREE
),
18881 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
18883 == error_mark_node
)
18889 /* Return the innermost template arguments that, when applied to a partial
18890 specialization of TMPL whose innermost template parameters are
18891 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
18894 For example, suppose we have:
18896 template <class T, class U> struct S {};
18897 template <class T> struct S<T*, int> {};
18899 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
18900 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
18901 int}. The resulting vector will be {double}, indicating that `T'
18902 is bound to `double'. */
18905 get_class_bindings (tree tmpl
, tree tparms
, tree spec_args
, tree args
)
18907 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
18909 tree innermost_deduced_args
;
18911 innermost_deduced_args
= make_tree_vec (ntparms
);
18912 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
18914 deduced_args
= copy_node (args
);
18915 SET_TMPL_ARGS_LEVEL (deduced_args
,
18916 TMPL_ARGS_DEPTH (deduced_args
),
18917 innermost_deduced_args
);
18920 deduced_args
= innermost_deduced_args
;
18922 if (unify (tparms
, deduced_args
,
18923 INNERMOST_TEMPLATE_ARGS (spec_args
),
18924 INNERMOST_TEMPLATE_ARGS (args
),
18925 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
18928 for (i
= 0; i
< ntparms
; ++i
)
18929 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
18932 /* Verify that nondeduced template arguments agree with the type
18933 obtained from argument deduction.
18937 struct A { typedef int X; };
18938 template <class T, class U> struct C {};
18939 template <class T> struct C<T, typename T::X> {};
18941 Then with the instantiation `C<A, int>', we can deduce that
18942 `T' is `A' but unify () does not check whether `typename T::X'
18944 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
18945 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
18947 tf_none
, false, false);
18948 if (spec_args
== error_mark_node
18949 /* We only need to check the innermost arguments; the other
18950 arguments will always agree. */
18951 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
18952 INNERMOST_TEMPLATE_ARGS (args
)))
18955 /* Now that we have bindings for all of the template arguments,
18956 ensure that the arguments deduced for the template template
18957 parameters have compatible template parameter lists. See the use
18958 of template_template_parm_bindings_ok_p in fn_type_unification
18959 for more information. */
18960 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
18963 return deduced_args
;
18966 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
18967 Return the TREE_LIST node with the most specialized template, if
18968 any. If there is no most specialized template, the error_mark_node
18971 Note that this function does not look at, or modify, the
18972 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
18973 returned is one of the elements of INSTANTIATIONS, callers may
18974 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
18975 and retrieve it from the value returned. */
18978 most_specialized_instantiation (tree templates
)
18982 ++processing_template_decl
;
18985 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
18989 if (get_bindings (TREE_VALUE (champ
),
18990 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
18991 NULL_TREE
, /*check_ret=*/true))
18994 if (get_bindings (TREE_VALUE (fn
),
18995 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
18996 NULL_TREE
, /*check_ret=*/true))
19003 /* Equally specialized, move to next function. If there
19004 is no next function, nothing's most specialized. */
19005 fn
= TREE_CHAIN (fn
);
19013 /* Now verify that champ is better than everything earlier in the
19014 instantiation list. */
19015 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
19016 if (get_bindings (TREE_VALUE (champ
),
19017 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
19018 NULL_TREE
, /*check_ret=*/true)
19019 || !get_bindings (TREE_VALUE (fn
),
19020 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
19021 NULL_TREE
, /*check_ret=*/true))
19027 processing_template_decl
--;
19030 return error_mark_node
;
19035 /* If DECL is a specialization of some template, return the most
19036 general such template. Otherwise, returns NULL_TREE.
19038 For example, given:
19040 template <class T> struct S { template <class U> void f(U); };
19042 if TMPL is `template <class U> void S<int>::f(U)' this will return
19043 the full template. This function will not trace past partial
19044 specializations, however. For example, given in addition:
19046 template <class T> struct S<T*> { template <class U> void f(U); };
19048 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19049 `template <class T> template <class U> S<T*>::f(U)'. */
19052 most_general_template (tree decl
)
19054 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19056 if (tree tinfo
= get_template_info (decl
))
19057 decl
= TI_TEMPLATE (tinfo
);
19058 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19059 template friend, or a FIELD_DECL for a capture pack. */
19060 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
19064 /* Look for more and more general templates. */
19065 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
19067 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19068 (See cp-tree.h for details.) */
19069 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
19072 if (CLASS_TYPE_P (TREE_TYPE (decl
))
19073 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
19076 /* Stop if we run into an explicitly specialized class template. */
19077 if (!DECL_NAMESPACE_SCOPE_P (decl
)
19078 && DECL_CONTEXT (decl
)
19079 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
19082 decl
= DECL_TI_TEMPLATE (decl
);
19088 /* Return the most specialized of the class template partial
19089 specializations which can produce TYPE, a specialization of some class
19090 template. The value returned is actually a TREE_LIST; the TREE_TYPE is
19091 a _TYPE node corresponding to the partial specialization, while the
19092 TREE_PURPOSE is the set of template arguments that must be
19093 substituted into the TREE_TYPE in order to generate TYPE.
19095 If the choice of partial specialization is ambiguous, a diagnostic
19096 is issued, and the error_mark_node is returned. If there are no
19097 partial specializations matching TYPE, then NULL_TREE is
19098 returned, indicating that the primary template should be used. */
19101 most_specialized_class (tree type
, tsubst_flags_t complain
)
19103 tree list
= NULL_TREE
;
19108 tree outer_args
= NULL_TREE
;
19110 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
19111 tree main_tmpl
= most_general_template (tmpl
);
19112 tree args
= CLASSTYPE_TI_ARGS (type
);
19114 /* For determining which partial specialization to use, only the
19115 innermost args are interesting. */
19116 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
19118 outer_args
= strip_innermost_template_args (args
, 1);
19119 args
= INNERMOST_TEMPLATE_ARGS (args
);
19122 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
19124 tree partial_spec_args
;
19126 tree spec_tmpl
= TREE_VALUE (t
);
19127 tree orig_parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19129 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
19131 ++processing_template_decl
;
19135 /* Discard the outer levels of args, and then substitute in the
19136 template args from the enclosing class. */
19137 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
19138 partial_spec_args
= tsubst_template_args
19139 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
19141 /* And the same for the partial specialization TEMPLATE_DECL. */
19142 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
19145 partial_spec_args
=
19146 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
19149 /*require_all_args=*/true,
19150 /*use_default_args=*/true);
19152 --processing_template_decl
;
19154 if (partial_spec_args
== error_mark_node
)
19155 return error_mark_node
;
19156 if (spec_tmpl
== error_mark_node
)
19157 return error_mark_node
;
19159 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
19160 spec_args
= get_class_bindings (tmpl
, parms
,
19166 spec_args
= add_to_template_args (outer_args
, spec_args
);
19167 list
= tree_cons (spec_args
, orig_parms
, list
);
19168 TREE_TYPE (list
) = TREE_TYPE (t
);
19175 ambiguous_p
= false;
19178 t
= TREE_CHAIN (t
);
19179 for (; t
; t
= TREE_CHAIN (t
))
19181 fate
= more_specialized_class (tmpl
, champ
, t
);
19188 t
= TREE_CHAIN (t
);
19191 ambiguous_p
= true;
19200 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
19202 fate
= more_specialized_class (tmpl
, champ
, t
);
19205 ambiguous_p
= true;
19213 char *spaces
= NULL
;
19214 if (!(complain
& tf_error
))
19215 return error_mark_node
;
19216 error ("ambiguous class template instantiation for %q#T", type
);
19217 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
19218 for (t
= list
; t
; t
= TREE_CHAIN (t
))
19220 error ("%s %+#T", spaces
? spaces
: str
, TREE_TYPE (t
));
19221 spaces
= spaces
? spaces
: get_spaces (str
);
19224 return error_mark_node
;
19230 /* Explicitly instantiate DECL. */
19233 do_decl_instantiation (tree decl
, tree storage
)
19235 tree result
= NULL_TREE
;
19238 if (!decl
|| decl
== error_mark_node
)
19239 /* An error occurred, for which grokdeclarator has already issued
19240 an appropriate message. */
19242 else if (! DECL_LANG_SPECIFIC (decl
))
19244 error ("explicit instantiation of non-template %q#D", decl
);
19248 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
19249 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
19251 if (VAR_P (decl
) && !var_templ
)
19253 /* There is an asymmetry here in the way VAR_DECLs and
19254 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19255 the latter, the DECL we get back will be marked as a
19256 template instantiation, and the appropriate
19257 DECL_TEMPLATE_INFO will be set up. This does not happen for
19258 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19259 should handle VAR_DECLs as it currently handles
19261 if (!DECL_CLASS_SCOPE_P (decl
))
19263 error ("%qD is not a static data member of a class template", decl
);
19266 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
19267 if (!result
|| !VAR_P (result
))
19269 error ("no matching template for %qD found", decl
);
19272 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
19274 error ("type %qT for explicit instantiation %qD does not match "
19275 "declared type %qT", TREE_TYPE (result
), decl
,
19280 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
19282 error ("explicit instantiation of %q#D", decl
);
19288 /* Check for various error cases. Note that if the explicit
19289 instantiation is valid the RESULT will currently be marked as an
19290 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19291 until we get here. */
19293 if (DECL_TEMPLATE_SPECIALIZATION (result
))
19295 /* DR 259 [temp.spec].
19297 Both an explicit instantiation and a declaration of an explicit
19298 specialization shall not appear in a program unless the explicit
19299 instantiation follows a declaration of the explicit specialization.
19301 For a given set of template parameters, if an explicit
19302 instantiation of a template appears after a declaration of an
19303 explicit specialization for that template, the explicit
19304 instantiation has no effect. */
19307 else if (DECL_EXPLICIT_INSTANTIATION (result
))
19311 No program shall explicitly instantiate any template more
19314 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19315 the first instantiation was `extern' and the second is not,
19316 and EXTERN_P for the opposite case. */
19317 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
19318 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
19319 /* If an "extern" explicit instantiation follows an ordinary
19320 explicit instantiation, the template is instantiated. */
19324 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
19326 error ("no matching template for %qD found", result
);
19329 else if (!DECL_TEMPLATE_INFO (result
))
19331 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
19335 if (storage
== NULL_TREE
)
19337 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19339 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
19340 pedwarn (input_location
, OPT_Wpedantic
,
19341 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19346 error ("storage class %qD applied to template instantiation", storage
);
19348 check_explicit_instantiation_namespace (result
);
19349 mark_decl_instantiated (result
, extern_p
);
19351 instantiate_decl (result
, /*defer_ok=*/1,
19352 /*expl_inst_class_mem_p=*/false);
19356 mark_class_instantiated (tree t
, int extern_p
)
19358 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
19359 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
19360 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
19361 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
19364 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
19365 rest_of_type_compilation (t
, 1);
19369 /* Called from do_type_instantiation through binding_table_foreach to
19370 do recursive instantiation for the type bound in ENTRY. */
19372 bt_instantiate_type_proc (binding_entry entry
, void *data
)
19374 tree storage
= *(tree
*) data
;
19376 if (MAYBE_CLASS_TYPE_P (entry
->type
)
19377 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
19378 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
19381 /* Called from do_type_instantiation to instantiate a member
19382 (a member function or a static member variable) of an
19383 explicitly instantiated class template. */
19385 instantiate_class_member (tree decl
, int extern_p
)
19387 mark_decl_instantiated (decl
, extern_p
);
19389 instantiate_decl (decl
, /*defer_ok=*/1,
19390 /*expl_inst_class_mem_p=*/true);
19393 /* Perform an explicit instantiation of template class T. STORAGE, if
19394 non-null, is the RID for extern, inline or static. COMPLAIN is
19395 nonzero if this is called from the parser, zero if called recursively,
19396 since the standard is unclear (as detailed below). */
19399 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
19404 int previous_instantiation_extern_p
= 0;
19406 if (TREE_CODE (t
) == TYPE_DECL
)
19409 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
19412 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
19414 error ("explicit instantiation of non-class template %qD", tmpl
);
19416 error ("explicit instantiation of non-template type %qT", t
);
19422 if (!COMPLETE_TYPE_P (t
))
19424 if (complain
& tf_error
)
19425 error ("explicit instantiation of %q#T before definition of template",
19430 if (storage
!= NULL_TREE
)
19432 if (!in_system_header_at (input_location
))
19434 if (storage
== ridpointers
[(int) RID_EXTERN
])
19436 if (cxx_dialect
== cxx98
)
19437 pedwarn (input_location
, OPT_Wpedantic
,
19438 "ISO C++ 1998 forbids the use of %<extern%> on "
19439 "explicit instantiations");
19442 pedwarn (input_location
, OPT_Wpedantic
,
19443 "ISO C++ forbids the use of %qE"
19444 " on explicit instantiations", storage
);
19447 if (storage
== ridpointers
[(int) RID_INLINE
])
19449 else if (storage
== ridpointers
[(int) RID_EXTERN
])
19451 else if (storage
== ridpointers
[(int) RID_STATIC
])
19455 error ("storage class %qD applied to template instantiation",
19461 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
19463 /* DR 259 [temp.spec].
19465 Both an explicit instantiation and a declaration of an explicit
19466 specialization shall not appear in a program unless the explicit
19467 instantiation follows a declaration of the explicit specialization.
19469 For a given set of template parameters, if an explicit
19470 instantiation of a template appears after a declaration of an
19471 explicit specialization for that template, the explicit
19472 instantiation has no effect. */
19475 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
19479 No program shall explicitly instantiate any template more
19482 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19483 instantiation was `extern'. If EXTERN_P then the second is.
19484 These cases are OK. */
19485 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
19487 if (!previous_instantiation_extern_p
&& !extern_p
19488 && (complain
& tf_error
))
19489 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
19491 /* If we've already instantiated the template, just return now. */
19492 if (!CLASSTYPE_INTERFACE_ONLY (t
))
19496 check_explicit_instantiation_namespace (TYPE_NAME (t
));
19497 mark_class_instantiated (t
, extern_p
);
19505 /* In contrast to implicit instantiation, where only the
19506 declarations, and not the definitions, of members are
19507 instantiated, we have here:
19511 The explicit instantiation of a class template specialization
19512 implies the instantiation of all of its members not
19513 previously explicitly specialized in the translation unit
19514 containing the explicit instantiation.
19516 Of course, we can't instantiate member template classes, since
19517 we don't have any arguments for them. Note that the standard
19518 is unclear on whether the instantiation of the members are
19519 *explicit* instantiations or not. However, the most natural
19520 interpretation is that it should be an explicit instantiation. */
19523 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19524 if (TREE_CODE (tmp
) == FUNCTION_DECL
19525 && DECL_TEMPLATE_INSTANTIATION (tmp
))
19526 instantiate_class_member (tmp
, extern_p
);
19528 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= DECL_CHAIN (tmp
))
19529 if (VAR_P (tmp
) && DECL_TEMPLATE_INSTANTIATION (tmp
))
19530 instantiate_class_member (tmp
, extern_p
);
19532 if (CLASSTYPE_NESTED_UTDS (t
))
19533 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
19534 bt_instantiate_type_proc
, &storage
);
19538 /* Given a function DECL, which is a specialization of TMPL, modify
19539 DECL to be a re-instantiation of TMPL with the same template
19540 arguments. TMPL should be the template into which tsubst'ing
19541 should occur for DECL, not the most general template.
19543 One reason for doing this is a scenario like this:
19546 void f(const T&, int i);
19548 void g() { f(3, 7); }
19551 void f(const T& t, const int i) { }
19553 Note that when the template is first instantiated, with
19554 instantiate_template, the resulting DECL will have no name for the
19555 first parameter, and the wrong type for the second. So, when we go
19556 to instantiate the DECL, we regenerate it. */
19559 regenerate_decl_from_template (tree decl
, tree tmpl
)
19561 /* The arguments used to instantiate DECL, from the most general
19566 args
= DECL_TI_ARGS (decl
);
19567 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
19569 /* Make sure that we can see identifiers, and compute access
19571 push_access_scope (decl
);
19573 if (TREE_CODE (decl
) == FUNCTION_DECL
)
19581 args_depth
= TMPL_ARGS_DEPTH (args
);
19582 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
19583 if (args_depth
> parms_depth
)
19584 args
= get_innermost_template_args (args
, parms_depth
);
19586 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
19587 args
, tf_error
, NULL_TREE
,
19588 /*defer_ok*/false);
19589 if (specs
&& specs
!= error_mark_node
)
19590 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
19593 /* Merge parameter declarations. */
19594 decl_parm
= skip_artificial_parms_for (decl
,
19595 DECL_ARGUMENTS (decl
));
19597 = skip_artificial_parms_for (code_pattern
,
19598 DECL_ARGUMENTS (code_pattern
));
19599 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
19604 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19605 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
19606 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
19608 parm_type
= type_decays_to (parm_type
);
19609 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19610 TREE_TYPE (decl_parm
) = parm_type
;
19611 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19612 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19614 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19615 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19617 decl_parm
= DECL_CHAIN (decl_parm
);
19618 pattern_parm
= DECL_CHAIN (pattern_parm
);
19620 /* Merge any parameters that match with the function parameter
19622 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
19625 tree expanded_types
;
19626 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19627 the parameters in this function parameter pack. */
19628 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
19629 args
, tf_error
, NULL_TREE
);
19630 len
= TREE_VEC_LENGTH (expanded_types
);
19631 for (i
= 0; i
< len
; i
++)
19636 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
19637 /* Rename the parameter to include the index. */
19638 DECL_NAME (decl_parm
) =
19639 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
19640 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
19641 parm_type
= type_decays_to (parm_type
);
19642 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
19643 TREE_TYPE (decl_parm
) = parm_type
;
19644 attributes
= DECL_ATTRIBUTES (pattern_parm
);
19645 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
19647 DECL_ATTRIBUTES (decl_parm
) = attributes
;
19648 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
19650 decl_parm
= DECL_CHAIN (decl_parm
);
19653 /* Merge additional specifiers from the CODE_PATTERN. */
19654 if (DECL_DECLARED_INLINE_P (code_pattern
)
19655 && !DECL_DECLARED_INLINE_P (decl
))
19656 DECL_DECLARED_INLINE_P (decl
) = 1;
19658 else if (VAR_P (decl
))
19660 DECL_INITIAL (decl
) =
19661 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
19662 tf_error
, DECL_TI_TEMPLATE (decl
),
19663 /*integral_constant_expression_p=*/false);
19664 if (VAR_HAD_UNKNOWN_BOUND (decl
))
19665 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
19666 tf_error
, DECL_TI_TEMPLATE (decl
));
19669 gcc_unreachable ();
19671 pop_access_scope (decl
);
19674 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19675 substituted to get DECL. */
19678 template_for_substitution (tree decl
)
19680 tree tmpl
= DECL_TI_TEMPLATE (decl
);
19682 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19683 for the instantiation. This is not always the most general
19684 template. Consider, for example:
19687 struct S { template <class U> void f();
19688 template <> void f<int>(); };
19690 and an instantiation of S<double>::f<int>. We want TD to be the
19691 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19692 while (/* An instantiation cannot have a definition, so we need a
19693 more general template. */
19694 DECL_TEMPLATE_INSTANTIATION (tmpl
)
19695 /* We must also deal with friend templates. Given:
19697 template <class T> struct S {
19698 template <class U> friend void f() {};
19701 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19702 so far as the language is concerned, but that's still
19703 where we get the pattern for the instantiation from. On
19704 other hand, if the definition comes outside the class, say:
19706 template <class T> struct S {
19707 template <class U> friend void f();
19709 template <class U> friend void f() {}
19711 we don't need to look any further. That's what the check for
19712 DECL_INITIAL is for. */
19713 || (TREE_CODE (decl
) == FUNCTION_DECL
19714 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
19715 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
19717 /* The present template, TD, should not be a definition. If it
19718 were a definition, we should be using it! Note that we
19719 cannot restructure the loop to just keep going until we find
19720 a template with a definition, since that might go too far if
19721 a specialization was declared, but not defined. */
19722 gcc_assert (!VAR_P (decl
)
19723 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
19725 /* Fetch the more general template. */
19726 tmpl
= DECL_TI_TEMPLATE (tmpl
);
19732 /* Returns true if we need to instantiate this template instance even if we
19733 know we aren't going to emit it.. */
19736 always_instantiate_p (tree decl
)
19738 /* We always instantiate inline functions so that we can inline them. An
19739 explicit instantiation declaration prohibits implicit instantiation of
19740 non-inline functions. With high levels of optimization, we would
19741 normally inline non-inline functions -- but we're not allowed to do
19742 that for "extern template" functions. Therefore, we check
19743 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19744 return ((TREE_CODE (decl
) == FUNCTION_DECL
19745 && (DECL_DECLARED_INLINE_P (decl
)
19746 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
19747 /* And we need to instantiate static data members so that
19748 their initializers are available in integral constant
19751 && decl_maybe_constant_var_p (decl
)));
19754 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19755 instantiate it now, modifying TREE_TYPE (fn). */
19758 maybe_instantiate_noexcept (tree fn
)
19760 tree fntype
, spec
, noex
, clone
;
19762 /* Don't instantiate a noexcept-specification from template context. */
19763 if (processing_template_decl
)
19766 if (DECL_CLONED_FUNCTION_P (fn
))
19767 fn
= DECL_CLONED_FUNCTION (fn
);
19768 fntype
= TREE_TYPE (fn
);
19769 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
19771 if (!spec
|| !TREE_PURPOSE (spec
))
19774 noex
= TREE_PURPOSE (spec
);
19776 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
19778 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
19779 spec
= get_defaulted_eh_spec (fn
);
19780 else if (push_tinst_level (fn
))
19782 push_access_scope (fn
);
19783 push_deferring_access_checks (dk_no_deferred
);
19784 input_location
= DECL_SOURCE_LOCATION (fn
);
19785 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
19786 DEFERRED_NOEXCEPT_ARGS (noex
),
19787 tf_warning_or_error
, fn
,
19788 /*function_p=*/false,
19789 /*integral_constant_expression_p=*/true);
19790 pop_deferring_access_checks ();
19791 pop_access_scope (fn
);
19792 pop_tinst_level ();
19793 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
19794 if (spec
== error_mark_node
)
19795 spec
= noexcept_false_spec
;
19798 spec
= noexcept_false_spec
;
19800 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
19803 FOR_EACH_CLONE (clone
, fn
)
19805 if (TREE_TYPE (clone
) == fntype
)
19806 TREE_TYPE (clone
) = TREE_TYPE (fn
);
19808 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
19812 /* Produce the definition of D, a _DECL generated from a template. If
19813 DEFER_OK is nonzero, then we don't have to actually do the
19814 instantiation now; we just have to do it sometime. Normally it is
19815 an error if this is an explicit instantiation but D is undefined.
19816 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19817 explicitly instantiated class template. */
19820 instantiate_decl (tree d
, int defer_ok
,
19821 bool expl_inst_class_mem_p
)
19823 tree tmpl
= DECL_TI_TEMPLATE (d
);
19830 bool pattern_defined
;
19831 location_t saved_loc
= input_location
;
19832 int saved_unevaluated_operand
= cp_unevaluated_operand
;
19833 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
19839 /* This function should only be used to instantiate templates for
19840 functions and static member variables. */
19841 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
19843 /* Variables are never deferred; if instantiation is required, they
19844 are instantiated right away. That allows for better code in the
19845 case that an expression refers to the value of the variable --
19846 if the variable has a constant value the referring expression can
19847 take advantage of that fact. */
19849 || DECL_DECLARED_CONSTEXPR_P (d
))
19852 /* Don't instantiate cloned functions. Instead, instantiate the
19853 functions they cloned. */
19854 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
19855 d
= DECL_CLONED_FUNCTION (d
);
19857 if (DECL_TEMPLATE_INSTANTIATED (d
)
19858 || (TREE_CODE (d
) == FUNCTION_DECL
19859 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
19860 || DECL_TEMPLATE_SPECIALIZATION (d
))
19861 /* D has already been instantiated or explicitly specialized, so
19862 there's nothing for us to do here.
19864 It might seem reasonable to check whether or not D is an explicit
19865 instantiation, and, if so, stop here. But when an explicit
19866 instantiation is deferred until the end of the compilation,
19867 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
19868 the instantiation. */
19871 /* Check to see whether we know that this template will be
19872 instantiated in some other file, as with "extern template"
19874 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
19876 /* In general, we do not instantiate such templates. */
19877 if (external_p
&& !always_instantiate_p (d
))
19880 gen_tmpl
= most_general_template (tmpl
);
19881 gen_args
= DECL_TI_ARGS (d
);
19883 if (tmpl
!= gen_tmpl
)
19884 /* We should already have the extra args. */
19885 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
19886 == TMPL_ARGS_DEPTH (gen_args
));
19887 /* And what's in the hash table should match D. */
19888 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
19889 || spec
== NULL_TREE
);
19891 /* This needs to happen before any tsubsting. */
19892 if (! push_tinst_level (d
))
19895 timevar_push (TV_TEMPLATE_INST
);
19897 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
19898 for the instantiation. */
19899 td
= template_for_substitution (d
);
19900 code_pattern
= DECL_TEMPLATE_RESULT (td
);
19902 /* We should never be trying to instantiate a member of a class
19903 template or partial specialization. */
19904 gcc_assert (d
!= code_pattern
);
19906 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
19907 || DECL_TEMPLATE_SPECIALIZATION (td
))
19908 /* In the case of a friend template whose definition is provided
19909 outside the class, we may have too many arguments. Drop the
19910 ones we don't need. The same is true for specializations. */
19911 args
= get_innermost_template_args
19912 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
19916 if (TREE_CODE (d
) == FUNCTION_DECL
)
19918 deleted_p
= DECL_DELETED_FN (code_pattern
);
19919 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
19920 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
19926 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
19929 /* We may be in the middle of deferred access check. Disable it now. */
19930 push_deferring_access_checks (dk_no_deferred
);
19932 /* Unless an explicit instantiation directive has already determined
19933 the linkage of D, remember that a definition is available for
19935 if (pattern_defined
19936 && !DECL_INTERFACE_KNOWN (d
)
19937 && !DECL_NOT_REALLY_EXTERN (d
))
19938 mark_definable (d
);
19940 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
19941 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
19942 input_location
= DECL_SOURCE_LOCATION (d
);
19944 /* If D is a member of an explicitly instantiated class template,
19945 and no definition is available, treat it like an implicit
19947 if (!pattern_defined
&& expl_inst_class_mem_p
19948 && DECL_EXPLICIT_INSTANTIATION (d
))
19950 /* Leave linkage flags alone on instantiations with anonymous
19952 if (TREE_PUBLIC (d
))
19954 DECL_NOT_REALLY_EXTERN (d
) = 0;
19955 DECL_INTERFACE_KNOWN (d
) = 0;
19957 SET_DECL_IMPLICIT_INSTANTIATION (d
);
19960 /* Defer all other templates, unless we have been explicitly
19961 forbidden from doing so. */
19962 if (/* If there is no definition, we cannot instantiate the
19965 /* If it's OK to postpone instantiation, do so. */
19967 /* If this is a static data member that will be defined
19968 elsewhere, we don't want to instantiate the entire data
19969 member, but we do want to instantiate the initializer so that
19970 we can substitute that elsewhere. */
19971 || (external_p
&& VAR_P (d
))
19972 /* Handle here a deleted function too, avoid generating
19973 its body (c++/61080). */
19976 /* The definition of the static data member is now required so
19977 we must substitute the initializer. */
19979 && !DECL_INITIAL (d
)
19980 && DECL_INITIAL (code_pattern
))
19984 bool const_init
= false;
19985 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
19987 ns
= decl_namespace_context (d
);
19988 push_nested_namespace (ns
);
19990 push_nested_class (DECL_CONTEXT (d
));
19991 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
19993 tf_warning_or_error
, NULL_TREE
,
19994 /*integral_constant_expression_p=*/false);
19995 /* Make sure the initializer is still constant, in case of
19996 circular dependency (template/instantiate6.C). */
19998 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
19999 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
20000 /*asmspec_tree=*/NULL_TREE
,
20001 LOOKUP_ONLYCONVERTING
);
20003 pop_nested_class ();
20004 pop_nested_namespace (ns
);
20007 /* We restore the source position here because it's used by
20008 add_pending_template. */
20009 input_location
= saved_loc
;
20011 if (at_eof
&& !pattern_defined
20012 && DECL_EXPLICIT_INSTANTIATION (d
)
20013 && DECL_NOT_REALLY_EXTERN (d
))
20016 The definition of a non-exported function template, a
20017 non-exported member function template, or a non-exported
20018 member function or static data member of a class template
20019 shall be present in every translation unit in which it is
20020 explicitly instantiated. */
20021 permerror (input_location
, "explicit instantiation of %qD "
20022 "but no definition available", d
);
20024 /* If we're in unevaluated context, we just wanted to get the
20025 constant value; this isn't an odr use, so don't queue
20026 a full instantiation. */
20027 if (cp_unevaluated_operand
!= 0)
20029 /* ??? Historically, we have instantiated inline functions, even
20030 when marked as "extern template". */
20031 if (!(external_p
&& VAR_P (d
)))
20032 add_pending_template (d
);
20035 /* Tell the repository that D is available in this translation unit
20036 -- and see if it is supposed to be instantiated here. */
20037 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
20039 /* In a PCH file, despite the fact that the repository hasn't
20040 requested instantiation in the PCH it is still possible that
20041 an instantiation will be required in a file that includes the
20044 add_pending_template (d
);
20045 /* Instantiate inline functions so that the inliner can do its
20046 job, even though we'll not be emitting a copy of this
20048 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
20052 fn_context
= decl_function_context (d
);
20053 nested
= (current_function_decl
!= NULL_TREE
);
20055 push_to_top_level ();
20059 push_function_context ();
20060 cp_unevaluated_operand
= 0;
20061 c_inhibit_evaluation_warnings
= 0;
20064 /* Mark D as instantiated so that recursive calls to
20065 instantiate_decl do not try to instantiate it again. */
20066 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
20068 /* Regenerate the declaration in case the template has been modified
20069 by a subsequent redeclaration. */
20070 regenerate_decl_from_template (d
, td
);
20072 /* We already set the file and line above. Reset them now in case
20073 they changed as a result of calling regenerate_decl_from_template. */
20074 input_location
= DECL_SOURCE_LOCATION (d
);
20079 bool const_init
= false;
20081 /* Clear out DECL_RTL; whatever was there before may not be right
20082 since we've reset the type of the declaration. */
20083 SET_DECL_RTL (d
, NULL
);
20084 DECL_IN_AGGR_P (d
) = 0;
20086 /* The initializer is placed in DECL_INITIAL by
20087 regenerate_decl_from_template so we don't need to
20088 push/pop_access_scope again here. Pull it out so that
20089 cp_finish_decl can process it. */
20090 init
= DECL_INITIAL (d
);
20091 DECL_INITIAL (d
) = NULL_TREE
;
20092 DECL_INITIALIZED_P (d
) = 0;
20094 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20095 initializer. That function will defer actual emission until
20096 we have a chance to determine linkage. */
20097 DECL_EXTERNAL (d
) = 0;
20099 /* Enter the scope of D so that access-checking works correctly. */
20100 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
20102 push_nested_class (DECL_CONTEXT (d
));
20104 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
20105 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
20108 pop_nested_class ();
20110 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
20111 synthesize_method (d
);
20112 else if (TREE_CODE (d
) == FUNCTION_DECL
)
20114 hash_map
<tree
, tree
> *saved_local_specializations
;
20118 tree block
= NULL_TREE
;
20120 /* Save away the current list, in case we are instantiating one
20121 template from within the body of another. */
20122 saved_local_specializations
= local_specializations
;
20124 /* Set up the list of local specializations. */
20125 local_specializations
= new hash_map
<tree
, tree
>;
20127 /* Set up context. */
20128 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20129 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20130 block
= push_stmt_list ();
20132 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
20134 /* Some typedefs referenced from within the template code need to be
20135 access checked at template instantiation time, i.e now. These
20136 types were added to the template at parsing time. Let's get those
20137 and perform the access checks then. */
20138 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl
),
20141 /* Create substitution entries for the parameters. */
20142 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
20143 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
20144 spec_parm
= DECL_ARGUMENTS (d
);
20145 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
20147 register_local_specialization (spec_parm
, tmpl_parm
);
20148 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
20149 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
20151 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
20153 if (!DECL_PACK_P (tmpl_parm
))
20155 register_local_specialization (spec_parm
, tmpl_parm
);
20156 spec_parm
= DECL_CHAIN (spec_parm
);
20160 /* Register the (value) argument pack as a specialization of
20161 TMPL_PARM, then move on. */
20162 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
20163 register_local_specialization (argpack
, tmpl_parm
);
20166 gcc_assert (!spec_parm
);
20168 /* Substitute into the body of the function. */
20169 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20170 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
20171 tf_warning_or_error
, tmpl
);
20174 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
20175 tf_warning_or_error
, tmpl
,
20176 /*integral_constant_expression_p=*/false);
20178 /* Set the current input_location to the end of the function
20179 so that finish_function knows where we are. */
20181 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
20183 /* Remember if we saw an infinite loop in the template. */
20184 current_function_infinite_loop
20185 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
20188 /* We don't need the local specializations any more. */
20189 delete local_specializations
;
20190 local_specializations
= saved_local_specializations
;
20192 /* Finish the function. */
20193 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
20194 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
20195 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
20198 d
= finish_function (0);
20199 expand_or_defer_fn (d
);
20202 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
20203 cp_check_omp_declare_reduction (d
);
20206 /* We're not deferring instantiation any more. */
20207 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
20210 pop_from_top_level ();
20212 pop_function_context ();
20215 input_location
= saved_loc
;
20216 cp_unevaluated_operand
= saved_unevaluated_operand
;
20217 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
20218 pop_deferring_access_checks ();
20219 pop_tinst_level ();
20221 timevar_pop (TV_TEMPLATE_INST
);
20226 /* Run through the list of templates that we wish we could
20227 instantiate, and instantiate any we can. RETRIES is the
20228 number of times we retry pending template instantiation. */
20231 instantiate_pending_templates (int retries
)
20234 location_t saved_loc
= input_location
;
20236 /* Instantiating templates may trigger vtable generation. This in turn
20237 may require further template instantiations. We place a limit here
20238 to avoid infinite loop. */
20239 if (pending_templates
&& retries
>= max_tinst_depth
)
20241 tree decl
= pending_templates
->tinst
->decl
;
20243 error ("template instantiation depth exceeds maximum of %d"
20244 " instantiating %q+D, possibly from virtual table generation"
20245 " (use -ftemplate-depth= to increase the maximum)",
20246 max_tinst_depth
, decl
);
20247 if (TREE_CODE (decl
) == FUNCTION_DECL
)
20248 /* Pretend that we defined it. */
20249 DECL_INITIAL (decl
) = error_mark_node
;
20255 struct pending_template
**t
= &pending_templates
;
20256 struct pending_template
*last
= NULL
;
20260 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
20261 bool complete
= false;
20263 if (TYPE_P (instantiation
))
20267 if (!COMPLETE_TYPE_P (instantiation
))
20269 instantiate_class_template (instantiation
);
20270 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
20271 for (fn
= TYPE_METHODS (instantiation
);
20273 fn
= TREE_CHAIN (fn
))
20274 if (! DECL_ARTIFICIAL (fn
))
20275 instantiate_decl (fn
,
20277 /*expl_inst_class_mem_p=*/false);
20278 if (COMPLETE_TYPE_P (instantiation
))
20282 complete
= COMPLETE_TYPE_P (instantiation
);
20286 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20287 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
20290 = instantiate_decl (instantiation
,
20292 /*expl_inst_class_mem_p=*/false);
20293 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
20297 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
20298 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
20302 /* If INSTANTIATION has been instantiated, then we don't
20303 need to consider it again in the future. */
20311 current_tinst_level
= NULL
;
20313 last_pending_template
= last
;
20315 while (reconsider
);
20317 input_location
= saved_loc
;
20320 /* Substitute ARGVEC into T, which is a list of initializers for
20321 either base class or a non-static data member. The TREE_PURPOSEs
20322 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20323 instantiate_decl. */
20326 tsubst_initializer_list (tree t
, tree argvec
)
20328 tree inits
= NULL_TREE
;
20330 for (; t
; t
= TREE_CHAIN (t
))
20334 tree expanded_bases
= NULL_TREE
;
20335 tree expanded_arguments
= NULL_TREE
;
20338 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
20343 /* Expand the base class expansion type into separate base
20345 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
20346 tf_warning_or_error
,
20348 if (expanded_bases
== error_mark_node
)
20351 /* We'll be building separate TREE_LISTs of arguments for
20353 len
= TREE_VEC_LENGTH (expanded_bases
);
20354 expanded_arguments
= make_tree_vec (len
);
20355 for (i
= 0; i
< len
; i
++)
20356 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
20358 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20359 expand each argument in the TREE_VALUE of t. */
20360 expr
= make_node (EXPR_PACK_EXPANSION
);
20361 PACK_EXPANSION_LOCAL_P (expr
) = true;
20362 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
20363 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
20365 if (TREE_VALUE (t
) == void_type_node
)
20366 /* VOID_TYPE_NODE is used to indicate
20367 value-initialization. */
20369 for (i
= 0; i
< len
; i
++)
20370 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
20374 /* Substitute parameter packs into each argument in the
20376 in_base_initializer
= 1;
20377 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
20379 tree expanded_exprs
;
20381 /* Expand the argument. */
20382 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
20384 = tsubst_pack_expansion (expr
, argvec
,
20385 tf_warning_or_error
,
20387 if (expanded_exprs
== error_mark_node
)
20390 /* Prepend each of the expanded expressions to the
20391 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20392 for (i
= 0; i
< len
; i
++)
20394 TREE_VEC_ELT (expanded_arguments
, i
) =
20395 tree_cons (NULL_TREE
,
20396 TREE_VEC_ELT (expanded_exprs
, i
),
20397 TREE_VEC_ELT (expanded_arguments
, i
));
20400 in_base_initializer
= 0;
20402 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20403 since we built them backwards. */
20404 for (i
= 0; i
< len
; i
++)
20406 TREE_VEC_ELT (expanded_arguments
, i
) =
20407 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
20412 for (i
= 0; i
< len
; ++i
)
20414 if (expanded_bases
)
20416 decl
= TREE_VEC_ELT (expanded_bases
, i
);
20417 decl
= expand_member_init (decl
);
20418 init
= TREE_VEC_ELT (expanded_arguments
, i
);
20423 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
20424 tf_warning_or_error
, NULL_TREE
);
20426 decl
= expand_member_init (decl
);
20427 if (decl
&& !DECL_P (decl
))
20428 in_base_initializer
= 1;
20430 init
= TREE_VALUE (t
);
20432 if (init
!= void_type_node
)
20433 init
= tsubst_expr (init
, argvec
,
20434 tf_warning_or_error
, NULL_TREE
,
20435 /*integral_constant_expression_p=*/false);
20436 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
20437 /* If we had an initializer but it instantiated to nothing,
20438 value-initialize the object. This will only occur when
20439 the initializer was a pack expansion where the parameter
20440 packs used in that expansion were of length zero. */
20441 init
= void_type_node
;
20442 in_base_initializer
= 0;
20447 init
= build_tree_list (decl
, init
);
20448 TREE_CHAIN (init
) = inits
;
20456 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20459 set_current_access_from_decl (tree decl
)
20461 if (TREE_PRIVATE (decl
))
20462 current_access_specifier
= access_private_node
;
20463 else if (TREE_PROTECTED (decl
))
20464 current_access_specifier
= access_protected_node
;
20466 current_access_specifier
= access_public_node
;
20469 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20470 is the instantiation (which should have been created with
20471 start_enum) and ARGS are the template arguments to use. */
20474 tsubst_enum (tree tag
, tree newtag
, tree args
)
20478 if (SCOPED_ENUM_P (newtag
))
20479 begin_scope (sk_scoped_enum
, newtag
);
20481 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
20486 decl
= TREE_VALUE (e
);
20487 /* Note that in a template enum, the TREE_VALUE is the
20488 CONST_DECL, not the corresponding INTEGER_CST. */
20489 value
= tsubst_expr (DECL_INITIAL (decl
),
20490 args
, tf_warning_or_error
, NULL_TREE
,
20491 /*integral_constant_expression_p=*/true);
20493 /* Give this enumeration constant the correct access. */
20494 set_current_access_from_decl (decl
);
20496 /* Actually build the enumerator itself. */
20498 (DECL_NAME (decl
), value
, newtag
, DECL_SOURCE_LOCATION (decl
));
20501 if (SCOPED_ENUM_P (newtag
))
20504 finish_enum_value_list (newtag
);
20505 finish_enum (newtag
);
20507 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
20508 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
20511 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20512 its type -- but without substituting the innermost set of template
20513 arguments. So, innermost set of template parameters will appear in
20517 get_mostly_instantiated_function_type (tree decl
)
20525 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
20526 targs
= DECL_TI_ARGS (decl
);
20527 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
20528 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
20530 /* There should be as many levels of arguments as there are levels
20532 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
20534 fn_type
= TREE_TYPE (tmpl
);
20536 if (parm_depth
== 1)
20537 /* No substitution is necessary. */
20544 /* Replace the innermost level of the TARGS with NULL_TREEs to
20545 let tsubst know not to substitute for those parameters. */
20546 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20547 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
20548 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
20549 TMPL_ARGS_LEVEL (targs
, i
));
20550 SET_TMPL_ARGS_LEVEL (partial_args
,
20551 TMPL_ARGS_DEPTH (targs
),
20552 make_tree_vec (DECL_NTPARMS (tmpl
)));
20554 /* Make sure that we can see identifiers, and compute access
20556 push_access_scope (decl
);
20558 ++processing_template_decl
;
20559 /* Now, do the (partial) substitution to figure out the
20560 appropriate function type. */
20561 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
20562 --processing_template_decl
;
20564 /* Substitute into the template parameters to obtain the real
20565 innermost set of parameters. This step is important if the
20566 innermost set of template parameters contains value
20567 parameters whose types depend on outer template parameters. */
20568 TREE_VEC_LENGTH (partial_args
)--;
20569 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
20571 pop_access_scope (decl
);
20577 /* Return truthvalue if we're processing a template different from
20578 the last one involved in diagnostics. */
20580 problematic_instantiation_changed (void)
20582 return current_tinst_level
!= last_error_tinst_level
;
20585 /* Remember current template involved in diagnostics. */
20587 record_last_problematic_instantiation (void)
20589 last_error_tinst_level
= current_tinst_level
;
20592 struct tinst_level
*
20593 current_instantiation (void)
20595 return current_tinst_level
;
20598 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20599 type. Return zero for ok, nonzero for disallowed. Issue error and
20600 warning messages under control of COMPLAIN. */
20603 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
20605 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
20607 else if (POINTER_TYPE_P (type
))
20609 else if (TYPE_PTRMEM_P (type
))
20611 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
20613 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
20615 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
20617 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
20620 if (complain
& tf_error
)
20622 if (type
== error_mark_node
)
20623 inform (input_location
, "invalid template non-type parameter");
20625 error ("%q#T is not a valid type for a template non-type parameter",
20631 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20632 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20635 dependent_type_p_r (tree type
)
20641 A type is dependent if it is:
20643 -- a template parameter. Template template parameters are types
20644 for us (since TYPE_P holds true for them) so we handle
20646 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
20647 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
20649 /* -- a qualified-id with a nested-name-specifier which contains a
20650 class-name that names a dependent type or whose unqualified-id
20651 names a dependent type. */
20652 if (TREE_CODE (type
) == TYPENAME_TYPE
)
20654 /* -- a cv-qualified type where the cv-unqualified type is
20656 type
= TYPE_MAIN_VARIANT (type
);
20657 /* -- a compound type constructed from any dependent type. */
20658 if (TYPE_PTRMEM_P (type
))
20659 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
20660 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20662 else if (TYPE_PTR_P (type
)
20663 || TREE_CODE (type
) == REFERENCE_TYPE
)
20664 return dependent_type_p (TREE_TYPE (type
));
20665 else if (TREE_CODE (type
) == FUNCTION_TYPE
20666 || TREE_CODE (type
) == METHOD_TYPE
)
20670 if (dependent_type_p (TREE_TYPE (type
)))
20672 for (arg_type
= TYPE_ARG_TYPES (type
);
20674 arg_type
= TREE_CHAIN (arg_type
))
20675 if (dependent_type_p (TREE_VALUE (arg_type
)))
20679 /* -- an array type constructed from any dependent type or whose
20680 size is specified by a constant expression that is
20683 We checked for type- and value-dependence of the bounds in
20684 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20685 if (TREE_CODE (type
) == ARRAY_TYPE
)
20687 if (TYPE_DOMAIN (type
)
20688 && dependent_type_p (TYPE_DOMAIN (type
)))
20690 return dependent_type_p (TREE_TYPE (type
));
20693 /* -- a template-id in which either the template name is a template
20695 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20697 /* ... or any of the template arguments is a dependent type or
20698 an expression that is type-dependent or value-dependent. */
20699 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
20700 && (any_dependent_template_arguments_p
20701 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
20704 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20705 dependent; if the argument of the `typeof' expression is not
20706 type-dependent, then it should already been have resolved. */
20707 if (TREE_CODE (type
) == TYPEOF_TYPE
20708 || TREE_CODE (type
) == DECLTYPE_TYPE
20709 || TREE_CODE (type
) == UNDERLYING_TYPE
)
20712 /* A template argument pack is dependent if any of its packed
20714 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
20716 tree args
= ARGUMENT_PACK_ARGS (type
);
20717 int i
, len
= TREE_VEC_LENGTH (args
);
20718 for (i
= 0; i
< len
; ++i
)
20719 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
20723 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20724 be template parameters. */
20725 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
20728 /* The standard does not specifically mention types that are local
20729 to template functions or local classes, but they should be
20730 considered dependent too. For example:
20732 template <int I> void f() {
20737 The size of `E' cannot be known until the value of `I' has been
20738 determined. Therefore, `E' must be considered dependent. */
20739 scope
= TYPE_CONTEXT (type
);
20740 if (scope
&& TYPE_P (scope
))
20741 return dependent_type_p (scope
);
20742 /* Don't use type_dependent_expression_p here, as it can lead
20743 to infinite recursion trying to determine whether a lambda
20744 nested in a lambda is dependent (c++/47687). */
20745 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
20746 && DECL_LANG_SPECIFIC (scope
)
20747 && DECL_TEMPLATE_INFO (scope
)
20748 && (any_dependent_template_arguments_p
20749 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
20752 /* Other types are non-dependent. */
20756 /* Returns TRUE if TYPE is dependent, in the sense of
20757 [temp.dep.type]. Note that a NULL type is considered dependent. */
20760 dependent_type_p (tree type
)
20762 /* If there are no template parameters in scope, then there can't be
20763 any dependent types. */
20764 if (!processing_template_decl
)
20766 /* If we are not processing a template, then nobody should be
20767 providing us with a dependent type. */
20769 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
20773 /* If the type is NULL, we have not computed a type for the entity
20774 in question; in that case, the type is dependent. */
20778 /* Erroneous types can be considered non-dependent. */
20779 if (type
== error_mark_node
)
20782 /* If we have not already computed the appropriate value for TYPE,
20784 if (!TYPE_DEPENDENT_P_VALID (type
))
20786 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
20787 TYPE_DEPENDENT_P_VALID (type
) = 1;
20790 return TYPE_DEPENDENT_P (type
);
20793 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20794 lookup. In other words, a dependent type that is not the current
20798 dependent_scope_p (tree scope
)
20800 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
20801 && !currently_open_class (scope
));
20804 /* T is a SCOPE_REF; return whether we need to consider it
20805 instantiation-dependent so that we can check access at instantiation
20806 time even though we know which member it resolves to. */
20809 instantiation_dependent_scope_ref_p (tree t
)
20811 if (DECL_P (TREE_OPERAND (t
, 1))
20812 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
20813 && accessible_in_template_p (TREE_OPERAND (t
, 0),
20814 TREE_OPERAND (t
, 1)))
20820 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20821 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20824 /* Note that this predicate is not appropriate for general expressions;
20825 only constant expressions (that satisfy potential_constant_expression)
20826 can be tested for value dependence. */
20829 value_dependent_expression_p (tree expression
)
20831 if (!processing_template_decl
)
20834 /* A name declared with a dependent type. */
20835 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
20838 switch (TREE_CODE (expression
))
20840 case IDENTIFIER_NODE
:
20841 /* A name that has not been looked up -- must be dependent. */
20844 case TEMPLATE_PARM_INDEX
:
20845 /* A non-type template parm. */
20849 /* A non-type template parm. */
20850 if (DECL_TEMPLATE_PARM_P (expression
))
20852 return value_dependent_expression_p (DECL_INITIAL (expression
));
20855 /* A constant with literal type and is initialized
20856 with an expression that is value-dependent.
20858 Note that a non-dependent parenthesized initializer will have
20859 already been replaced with its constant value, so if we see
20860 a TREE_LIST it must be dependent. */
20861 if (DECL_INITIAL (expression
)
20862 && decl_constant_var_p (expression
)
20863 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
20864 || value_dependent_expression_p (DECL_INITIAL (expression
))))
20868 case DYNAMIC_CAST_EXPR
:
20869 case STATIC_CAST_EXPR
:
20870 case CONST_CAST_EXPR
:
20871 case REINTERPRET_CAST_EXPR
:
20873 /* These expressions are value-dependent if the type to which
20874 the cast occurs is dependent or the expression being casted
20875 is value-dependent. */
20877 tree type
= TREE_TYPE (expression
);
20879 if (dependent_type_p (type
))
20882 /* A functional cast has a list of operands. */
20883 expression
= TREE_OPERAND (expression
, 0);
20886 /* If there are no operands, it must be an expression such
20887 as "int()". This should not happen for aggregate types
20888 because it would form non-constant expressions. */
20889 gcc_assert (cxx_dialect
>= cxx11
20890 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
20895 if (TREE_CODE (expression
) == TREE_LIST
)
20896 return any_value_dependent_elements_p (expression
);
20898 return value_dependent_expression_p (expression
);
20902 if (SIZEOF_EXPR_TYPE_P (expression
))
20903 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
20907 /* A `sizeof' expression is value-dependent if the operand is
20908 type-dependent or is a pack expansion. */
20909 expression
= TREE_OPERAND (expression
, 0);
20910 if (PACK_EXPANSION_P (expression
))
20912 else if (TYPE_P (expression
))
20913 return dependent_type_p (expression
);
20914 return instantiation_dependent_expression_p (expression
);
20916 case AT_ENCODE_EXPR
:
20917 /* An 'encode' expression is value-dependent if the operand is
20919 expression
= TREE_OPERAND (expression
, 0);
20920 return dependent_type_p (expression
);
20922 case NOEXCEPT_EXPR
:
20923 expression
= TREE_OPERAND (expression
, 0);
20924 return instantiation_dependent_expression_p (expression
);
20927 /* All instantiation-dependent expressions should also be considered
20928 value-dependent. */
20929 return instantiation_dependent_scope_ref_p (expression
);
20931 case COMPONENT_REF
:
20932 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
20933 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
20935 case NONTYPE_ARGUMENT_PACK
:
20936 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
20937 is value-dependent. */
20939 tree values
= ARGUMENT_PACK_ARGS (expression
);
20940 int i
, len
= TREE_VEC_LENGTH (values
);
20942 for (i
= 0; i
< len
; ++i
)
20943 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
20951 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
20952 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
20953 || (type2
? dependent_type_p (type2
) : false));
20957 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20958 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
20961 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
20962 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
20966 tree op
= TREE_OPERAND (expression
, 0);
20967 return (value_dependent_expression_p (op
)
20968 || has_value_dependent_address (op
));
20973 tree fn
= get_callee_fndecl (expression
);
20975 if (!fn
&& value_dependent_expression_p (CALL_EXPR_FN (expression
)))
20977 nargs
= call_expr_nargs (expression
);
20978 for (i
= 0; i
< nargs
; ++i
)
20980 tree op
= CALL_EXPR_ARG (expression
, i
);
20981 /* In a call to a constexpr member function, look through the
20982 implicit ADDR_EXPR on the object argument so that it doesn't
20983 cause the call to be considered value-dependent. We also
20984 look through it in potential_constant_expression. */
20985 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
20986 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
20987 && TREE_CODE (op
) == ADDR_EXPR
)
20988 op
= TREE_OPERAND (op
, 0);
20989 if (value_dependent_expression_p (op
))
20995 case TEMPLATE_ID_EXPR
:
20996 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
20998 return type_dependent_expression_p (expression
);
21004 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
21005 if (value_dependent_expression_p (val
))
21011 /* Treat a GNU statement expression as dependent to avoid crashing
21012 under fold_non_dependent_expr; it can't be constant. */
21016 /* A constant expression is value-dependent if any subexpression is
21017 value-dependent. */
21018 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
21020 case tcc_reference
:
21022 case tcc_comparison
:
21024 case tcc_expression
:
21027 int i
, len
= cp_tree_operand_length (expression
);
21029 for (i
= 0; i
< len
; i
++)
21031 tree t
= TREE_OPERAND (expression
, i
);
21033 /* In some cases, some of the operands may be missing.l
21034 (For example, in the case of PREDECREMENT_EXPR, the
21035 amount to increment by may be missing.) That doesn't
21036 make the expression dependent. */
21037 if (t
&& value_dependent_expression_p (t
))
21048 /* The expression is not value-dependent. */
21052 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21053 [temp.dep.expr]. Note that an expression with no type is
21054 considered dependent. Other parts of the compiler arrange for an
21055 expression with type-dependent subexpressions to have no type, so
21056 this function doesn't have to be fully recursive. */
21059 type_dependent_expression_p (tree expression
)
21061 if (!processing_template_decl
)
21064 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
21067 /* An unresolved name is always dependent. */
21068 if (identifier_p (expression
) || TREE_CODE (expression
) == USING_DECL
)
21071 /* Some expression forms are never type-dependent. */
21072 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
21073 || TREE_CODE (expression
) == SIZEOF_EXPR
21074 || TREE_CODE (expression
) == ALIGNOF_EXPR
21075 || TREE_CODE (expression
) == AT_ENCODE_EXPR
21076 || TREE_CODE (expression
) == NOEXCEPT_EXPR
21077 || TREE_CODE (expression
) == TRAIT_EXPR
21078 || TREE_CODE (expression
) == TYPEID_EXPR
21079 || TREE_CODE (expression
) == DELETE_EXPR
21080 || TREE_CODE (expression
) == VEC_DELETE_EXPR
21081 || TREE_CODE (expression
) == THROW_EXPR
)
21084 /* The types of these expressions depends only on the type to which
21085 the cast occurs. */
21086 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
21087 || TREE_CODE (expression
) == STATIC_CAST_EXPR
21088 || TREE_CODE (expression
) == CONST_CAST_EXPR
21089 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
21090 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
21091 || TREE_CODE (expression
) == CAST_EXPR
)
21092 return dependent_type_p (TREE_TYPE (expression
));
21094 /* The types of these expressions depends only on the type created
21095 by the expression. */
21096 if (TREE_CODE (expression
) == NEW_EXPR
21097 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
21099 /* For NEW_EXPR tree nodes created inside a template, either
21100 the object type itself or a TREE_LIST may appear as the
21102 tree type
= TREE_OPERAND (expression
, 1);
21103 if (TREE_CODE (type
) == TREE_LIST
)
21104 /* This is an array type. We need to check array dimensions
21106 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
21107 || value_dependent_expression_p
21108 (TREE_OPERAND (TREE_VALUE (type
), 1));
21110 return dependent_type_p (type
);
21113 if (TREE_CODE (expression
) == SCOPE_REF
)
21115 tree scope
= TREE_OPERAND (expression
, 0);
21116 tree name
= TREE_OPERAND (expression
, 1);
21118 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21119 contains an identifier associated by name lookup with one or more
21120 declarations declared with a dependent type, or...a
21121 nested-name-specifier or qualified-id that names a member of an
21122 unknown specialization. */
21123 return (type_dependent_expression_p (name
)
21124 || dependent_scope_p (scope
));
21127 if (TREE_CODE (expression
) == FUNCTION_DECL
21128 && DECL_LANG_SPECIFIC (expression
)
21129 && DECL_TEMPLATE_INFO (expression
)
21130 && (any_dependent_template_arguments_p
21131 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
21134 if (TREE_CODE (expression
) == TEMPLATE_DECL
21135 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
21138 if (TREE_CODE (expression
) == STMT_EXPR
)
21139 expression
= stmt_expr_value_expr (expression
);
21141 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
21146 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
21148 if (type_dependent_expression_p (elt
))
21154 /* A static data member of the current instantiation with incomplete
21155 array type is type-dependent, as the definition and specializations
21156 can have different bounds. */
21157 if (VAR_P (expression
)
21158 && DECL_CLASS_SCOPE_P (expression
)
21159 && dependent_type_p (DECL_CONTEXT (expression
))
21160 && VAR_HAD_UNKNOWN_BOUND (expression
))
21163 /* An array of unknown bound depending on a variadic parameter, eg:
21165 template<typename... Args>
21166 void foo (Args... args)
21168 int arr[] = { args... };
21171 template<int... vals>
21174 int arr[] = { vals... };
21177 If the array has no length and has an initializer, it must be that
21178 we couldn't determine its length in cp_complete_array_type because
21179 it is dependent. */
21180 if (VAR_P (expression
)
21181 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
21182 && !TYPE_DOMAIN (TREE_TYPE (expression
))
21183 && DECL_INITIAL (expression
))
21186 if (TREE_TYPE (expression
) == unknown_type_node
)
21188 if (TREE_CODE (expression
) == ADDR_EXPR
)
21189 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
21190 if (TREE_CODE (expression
) == COMPONENT_REF
21191 || TREE_CODE (expression
) == OFFSET_REF
)
21193 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
21195 expression
= TREE_OPERAND (expression
, 1);
21196 if (identifier_p (expression
))
21199 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21200 if (TREE_CODE (expression
) == SCOPE_REF
)
21203 /* Always dependent, on the number of arguments if nothing else. */
21204 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
21207 if (BASELINK_P (expression
))
21209 if (BASELINK_OPTYPE (expression
)
21210 && dependent_type_p (BASELINK_OPTYPE (expression
)))
21212 expression
= BASELINK_FUNCTIONS (expression
);
21215 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
21217 if (any_dependent_template_arguments_p
21218 (TREE_OPERAND (expression
, 1)))
21220 expression
= TREE_OPERAND (expression
, 0);
21222 gcc_assert (TREE_CODE (expression
) == OVERLOAD
21223 || TREE_CODE (expression
) == FUNCTION_DECL
);
21227 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
21229 expression
= OVL_NEXT (expression
);
21234 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
21236 return (dependent_type_p (TREE_TYPE (expression
)));
21239 /* walk_tree callback function for instantiation_dependent_expression_p,
21240 below. Returns non-zero if a dependent subexpression is found. */
21243 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
21248 /* We don't have to worry about decltype currently because decltype
21249 of an instantiation-dependent expr is a dependent type. This
21250 might change depending on the resolution of DR 1172. */
21251 *walk_subtrees
= false;
21254 enum tree_code code
= TREE_CODE (*tp
);
21257 /* Don't treat an argument list as dependent just because it has no
21265 /* A constant with a dependent initializer is dependent. */
21266 if (value_dependent_expression_p (*tp
))
21270 case TEMPLATE_PARM_INDEX
:
21273 /* Handle expressions with type operands. */
21277 case AT_ENCODE_EXPR
:
21279 tree op
= TREE_OPERAND (*tp
, 0);
21280 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
21281 op
= TREE_TYPE (op
);
21284 if (dependent_type_p (op
))
21288 *walk_subtrees
= false;
21296 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp
))
21297 || (TRAIT_EXPR_TYPE2 (*tp
)
21298 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp
))))
21300 *walk_subtrees
= false;
21303 case COMPONENT_REF
:
21304 if (identifier_p (TREE_OPERAND (*tp
, 1)))
21305 /* In a template, finish_class_member_access_expr creates a
21306 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21307 type-dependent, so that we can check access control at
21308 instantiation time (PR 42277). See also Core issue 1273. */
21313 if (instantiation_dependent_scope_ref_p (*tp
))
21318 /* Treat statement-expressions as dependent. */
21326 if (type_dependent_expression_p (*tp
))
21332 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21333 sense defined by the ABI:
21335 "An expression is instantiation-dependent if it is type-dependent
21336 or value-dependent, or it has a subexpression that is type-dependent
21337 or value-dependent." */
21340 instantiation_dependent_expression_p (tree expression
)
21344 if (!processing_template_decl
)
21347 if (expression
== error_mark_node
)
21350 result
= cp_walk_tree_without_duplicates (&expression
,
21351 instantiation_dependent_r
, NULL
);
21352 return result
!= NULL_TREE
;
21355 /* Like type_dependent_expression_p, but it also works while not processing
21356 a template definition, i.e. during substitution or mangling. */
21359 type_dependent_expression_p_push (tree expr
)
21362 ++processing_template_decl
;
21363 b
= type_dependent_expression_p (expr
);
21364 --processing_template_decl
;
21368 /* Returns TRUE if ARGS contains a type-dependent expression. */
21371 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
21376 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
21378 if (type_dependent_expression_p (arg
))
21384 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21385 expressions) contains any type-dependent expressions. */
21388 any_type_dependent_elements_p (const_tree list
)
21390 for (; list
; list
= TREE_CHAIN (list
))
21391 if (type_dependent_expression_p (TREE_VALUE (list
)))
21397 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21398 expressions) contains any value-dependent expressions. */
21401 any_value_dependent_elements_p (const_tree list
)
21403 for (; list
; list
= TREE_CHAIN (list
))
21404 if (value_dependent_expression_p (TREE_VALUE (list
)))
21410 /* Returns TRUE if the ARG (a template argument) is dependent. */
21413 dependent_template_arg_p (tree arg
)
21415 if (!processing_template_decl
)
21418 /* Assume a template argument that was wrongly written by the user
21419 is dependent. This is consistent with what
21420 any_dependent_template_arguments_p [that calls this function]
21422 if (!arg
|| arg
== error_mark_node
)
21425 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
21426 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
21428 if (TREE_CODE (arg
) == TEMPLATE_DECL
21429 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
21430 return dependent_template_p (arg
);
21431 else if (ARGUMENT_PACK_P (arg
))
21433 tree args
= ARGUMENT_PACK_ARGS (arg
);
21434 int i
, len
= TREE_VEC_LENGTH (args
);
21435 for (i
= 0; i
< len
; ++i
)
21437 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
21443 else if (TYPE_P (arg
))
21444 return dependent_type_p (arg
);
21446 return (type_dependent_expression_p (arg
)
21447 || value_dependent_expression_p (arg
));
21450 /* Returns true if ARGS (a collection of template arguments) contains
21451 any types that require structural equality testing. */
21454 any_template_arguments_need_structural_equality_p (tree args
)
21461 if (args
== error_mark_node
)
21464 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21466 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21467 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21469 tree arg
= TREE_VEC_ELT (level
, j
);
21470 tree packed_args
= NULL_TREE
;
21473 if (ARGUMENT_PACK_P (arg
))
21475 /* Look inside the argument pack. */
21476 packed_args
= ARGUMENT_PACK_ARGS (arg
);
21477 len
= TREE_VEC_LENGTH (packed_args
);
21480 for (k
= 0; k
< len
; ++k
)
21483 arg
= TREE_VEC_ELT (packed_args
, k
);
21485 if (error_operand_p (arg
))
21487 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
21489 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
21491 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
21492 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
21501 /* Returns true if ARGS (a collection of template arguments) contains
21502 any dependent arguments. */
21505 any_dependent_template_arguments_p (const_tree args
)
21512 if (args
== error_mark_node
)
21515 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
21517 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
21518 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
21519 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
21526 /* Returns TRUE if the template TMPL is dependent. */
21529 dependent_template_p (tree tmpl
)
21531 if (TREE_CODE (tmpl
) == OVERLOAD
)
21535 if (dependent_template_p (OVL_CURRENT (tmpl
)))
21537 tmpl
= OVL_NEXT (tmpl
);
21542 /* Template template parameters are dependent. */
21543 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
21544 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
21546 /* So are names that have not been looked up. */
21547 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
21549 /* So are member templates of dependent classes. */
21550 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
21551 return dependent_type_p (DECL_CONTEXT (tmpl
));
21555 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21558 dependent_template_id_p (tree tmpl
, tree args
)
21560 return (dependent_template_p (tmpl
)
21561 || any_dependent_template_arguments_p (args
));
21564 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21568 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
21572 if (!processing_template_decl
)
21575 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
21577 tree decl
= TREE_VEC_ELT (declv
, i
);
21578 tree init
= TREE_VEC_ELT (initv
, i
);
21579 tree cond
= TREE_VEC_ELT (condv
, i
);
21580 tree incr
= TREE_VEC_ELT (incrv
, i
);
21582 if (type_dependent_expression_p (decl
))
21585 if (init
&& type_dependent_expression_p (init
))
21588 if (type_dependent_expression_p (cond
))
21591 if (COMPARISON_CLASS_P (cond
)
21592 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
21593 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
21596 if (TREE_CODE (incr
) == MODOP_EXPR
)
21598 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
21599 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
21602 else if (type_dependent_expression_p (incr
))
21604 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
21606 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
21608 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
21610 tree t
= TREE_OPERAND (incr
, 1);
21611 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
21612 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
21621 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21622 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21623 no such TYPE can be found. Note that this function peers inside
21624 uninstantiated templates and therefore should be used only in
21625 extremely limited situations. ONLY_CURRENT_P restricts this
21626 peering to the currently open classes hierarchy (which is required
21627 when comparing types). */
21630 resolve_typename_type (tree type
, bool only_current_p
)
21639 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
21641 scope
= TYPE_CONTEXT (type
);
21642 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21643 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21644 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21645 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21646 identifier of the TYPENAME_TYPE anymore.
21647 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21648 TYPENAME_TYPE instead, we avoid messing up with a possible
21649 typedef variant case. */
21650 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
21652 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21653 it first before we can figure out what NAME refers to. */
21654 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21656 if (TYPENAME_IS_RESOLVING_P (scope
))
21657 /* Given a class template A with a dependent base with nested type C,
21658 typedef typename A::C::C C will land us here, as trying to resolve
21659 the initial A::C leads to the local C typedef, which leads back to
21660 A::C::C. So we break the recursion now. */
21663 scope
= resolve_typename_type (scope
, only_current_p
);
21665 /* If we don't know what SCOPE refers to, then we cannot resolve the
21667 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
21669 /* If the SCOPE is a template type parameter, we have no way of
21670 resolving the name. */
21671 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
21673 /* If the SCOPE is not the current instantiation, there's no reason
21674 to look inside it. */
21675 if (only_current_p
&& !currently_open_class (scope
))
21677 /* If this is a typedef, we don't want to look inside (c++/11987). */
21678 if (typedef_variant_p (type
))
21680 /* If SCOPE isn't the template itself, it will not have a valid
21681 TYPE_FIELDS list. */
21682 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
21683 /* scope is either the template itself or a compatible instantiation
21684 like X<T>, so look up the name in the original template. */
21685 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
21687 /* scope is a partial instantiation, so we can't do the lookup or we
21688 will lose the template arguments. */
21690 /* Enter the SCOPE so that name lookup will be resolved as if we
21691 were in the class definition. In particular, SCOPE will no
21692 longer be considered a dependent type. */
21693 pushed_scope
= push_scope (scope
);
21694 /* Look up the declaration. */
21695 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
21696 tf_warning_or_error
);
21698 result
= NULL_TREE
;
21700 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21701 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21704 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type
))
21705 && TREE_CODE (decl
) == TYPE_DECL
)
21707 result
= TREE_TYPE (decl
);
21708 if (result
== error_mark_node
)
21709 result
= NULL_TREE
;
21711 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
21712 && DECL_CLASS_TEMPLATE_P (decl
))
21716 /* Obtain the template and the arguments. */
21717 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
21718 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
21719 /* Instantiate the template. */
21720 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
21721 /*entering_scope=*/0,
21722 tf_error
| tf_user
);
21723 if (result
== error_mark_node
)
21724 result
= NULL_TREE
;
21727 /* Leave the SCOPE. */
21729 pop_scope (pushed_scope
);
21731 /* If we failed to resolve it, return the original typename. */
21735 /* If lookup found a typename type, resolve that too. */
21736 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
21738 /* Ill-formed programs can cause infinite recursion here, so we
21739 must catch that. */
21740 TYPENAME_IS_RESOLVING_P (type
) = 1;
21741 result
= resolve_typename_type (result
, only_current_p
);
21742 TYPENAME_IS_RESOLVING_P (type
) = 0;
21745 /* Qualify the resulting type. */
21746 quals
= cp_type_quals (type
);
21748 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
21753 /* EXPR is an expression which is not type-dependent. Return a proxy
21754 for EXPR that can be used to compute the types of larger
21755 expressions containing EXPR. */
21758 build_non_dependent_expr (tree expr
)
21762 #ifdef ENABLE_CHECKING
21763 /* Try to get a constant value for all non-dependent expressions in
21764 order to expose bugs in *_dependent_expression_p and constexpr. */
21765 if (cxx_dialect
>= cxx11
)
21766 maybe_constant_value (fold_non_dependent_expr_sfinae (expr
, tf_none
));
21769 /* Preserve OVERLOADs; the functions must be available to resolve
21772 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
21773 inner_expr
= stmt_expr_value_expr (inner_expr
);
21774 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
21775 inner_expr
= TREE_OPERAND (inner_expr
, 0);
21776 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
21777 inner_expr
= TREE_OPERAND (inner_expr
, 1);
21778 if (is_overloaded_fn (inner_expr
)
21779 || TREE_CODE (inner_expr
) == OFFSET_REF
)
21781 /* There is no need to return a proxy for a variable. */
21784 /* Preserve string constants; conversions from string constants to
21785 "char *" are allowed, even though normally a "const char *"
21786 cannot be used to initialize a "char *". */
21787 if (TREE_CODE (expr
) == STRING_CST
)
21789 /* Preserve void and arithmetic constants, as an optimization -- there is no
21790 reason to create a new node. */
21791 if (TREE_CODE (expr
) == VOID_CST
21792 || TREE_CODE (expr
) == INTEGER_CST
21793 || TREE_CODE (expr
) == REAL_CST
)
21795 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21796 There is at least one place where we want to know that a
21797 particular expression is a throw-expression: when checking a ?:
21798 expression, there are special rules if the second or third
21799 argument is a throw-expression. */
21800 if (TREE_CODE (expr
) == THROW_EXPR
)
21803 /* Don't wrap an initializer list, we need to be able to look inside. */
21804 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
21807 /* Don't wrap a dummy object, we need to be able to test for it. */
21808 if (is_dummy_object (expr
))
21811 if (TREE_CODE (expr
) == COND_EXPR
)
21812 return build3 (COND_EXPR
,
21814 TREE_OPERAND (expr
, 0),
21815 (TREE_OPERAND (expr
, 1)
21816 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
21817 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
21818 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
21819 if (TREE_CODE (expr
) == COMPOUND_EXPR
21820 && !COMPOUND_EXPR_OVERLOADED (expr
))
21821 return build2 (COMPOUND_EXPR
,
21823 TREE_OPERAND (expr
, 0),
21824 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
21826 /* If the type is unknown, it can't really be non-dependent */
21827 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
21829 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21830 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
21833 /* ARGS is a vector of expressions as arguments to a function call.
21834 Replace the arguments with equivalent non-dependent expressions.
21835 This modifies ARGS in place. */
21838 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
21843 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
21845 tree newarg
= build_non_dependent_expr (arg
);
21847 (*args
)[ix
] = newarg
;
21851 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
21852 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
21856 make_auto_1 (tree name
)
21858 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
21859 TYPE_NAME (au
) = build_decl (input_location
,
21860 TYPE_DECL
, name
, au
);
21861 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
21862 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
21863 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
21864 TYPE_NAME (au
), NULL_TREE
);
21865 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
21866 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
21867 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
21873 make_decltype_auto (void)
21875 return make_auto_1 (get_identifier ("decltype(auto)"));
21881 return make_auto_1 (get_identifier ("auto"));
21884 /* Given type ARG, return std::initializer_list<ARG>. */
21889 tree std_init_list
= namespace_binding
21890 (get_identifier ("initializer_list"), std_node
);
21892 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
21894 error ("deducing from brace-enclosed initializer list requires "
21895 "#include <initializer_list>");
21896 return error_mark_node
;
21898 argvec
= make_tree_vec (1);
21899 TREE_VEC_ELT (argvec
, 0) = arg
;
21900 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
21901 NULL_TREE
, 0, tf_warning_or_error
);
21904 /* Replace auto in TYPE with std::initializer_list<auto>. */
21907 listify_autos (tree type
, tree auto_node
)
21909 tree init_auto
= listify (auto_node
);
21910 tree argvec
= make_tree_vec (1);
21911 TREE_VEC_ELT (argvec
, 0) = init_auto
;
21912 if (processing_template_decl
)
21913 argvec
= add_to_template_args (current_template_args (), argvec
);
21914 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
21917 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
21918 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
21921 do_auto_deduction (tree type
, tree init
, tree auto_node
)
21925 if (init
== error_mark_node
)
21926 return error_mark_node
;
21928 if (type_dependent_expression_p (init
))
21929 /* Defining a subset of type-dependent expressions that we can deduce
21930 from ahead of time isn't worth the trouble. */
21933 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
21934 with either a new invented type template parameter U or, if the
21935 initializer is a braced-init-list (8.5.4), with
21936 std::initializer_list<U>. */
21937 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
21938 type
= listify_autos (type
, auto_node
);
21940 init
= resolve_nondeduced_context (init
);
21942 targs
= make_tree_vec (1);
21943 if (AUTO_IS_DECLTYPE (auto_node
))
21945 bool id
= (DECL_P (init
) || (TREE_CODE (init
) == COMPONENT_REF
21946 && !REF_PARENTHESIZED_P (init
)));
21947 TREE_VEC_ELT (targs
, 0)
21948 = finish_decltype_type (init
, id
, tf_warning_or_error
);
21949 if (type
!= auto_node
)
21951 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
21952 return error_mark_node
;
21957 tree parms
= build_tree_list (NULL_TREE
, type
);
21958 tree tparms
= make_tree_vec (1);
21961 TREE_VEC_ELT (tparms
, 0)
21962 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
21963 val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
21964 DEDUCE_CALL
, LOOKUP_NORMAL
,
21965 NULL
, /*explain_p=*/false);
21968 if (processing_template_decl
)
21969 /* Try again at instantiation time. */
21971 if (type
&& type
!= error_mark_node
)
21972 /* If type is error_mark_node a diagnostic must have been
21973 emitted by now. Also, having a mention to '<type error>'
21974 in the diagnostic is not really useful to the user. */
21976 if (cfun
&& auto_node
== current_function_auto_return_pattern
21977 && LAMBDA_FUNCTION_P (current_function_decl
))
21978 error ("unable to deduce lambda return type from %qE", init
);
21980 error ("unable to deduce %qT from %qE", type
, init
);
21982 return error_mark_node
;
21986 /* If the list of declarators contains more than one declarator, the type
21987 of each declared variable is determined as described above. If the
21988 type deduced for the template parameter U is not the same in each
21989 deduction, the program is ill-formed. */
21990 if (TREE_TYPE (auto_node
)
21991 && !same_type_p (TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0)))
21993 if (cfun
&& auto_node
== current_function_auto_return_pattern
21994 && LAMBDA_FUNCTION_P (current_function_decl
))
21995 error ("inconsistent types %qT and %qT deduced for "
21996 "lambda return type", TREE_TYPE (auto_node
),
21997 TREE_VEC_ELT (targs
, 0));
21999 error ("inconsistent deduction for %qT: %qT and then %qT",
22000 auto_node
, TREE_TYPE (auto_node
), TREE_VEC_ELT (targs
, 0));
22001 return error_mark_node
;
22003 TREE_TYPE (auto_node
) = TREE_VEC_ELT (targs
, 0);
22005 if (processing_template_decl
)
22006 targs
= add_to_template_args (current_template_args (), targs
);
22007 return tsubst (type
, targs
, tf_warning_or_error
, NULL_TREE
);
22010 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22014 splice_late_return_type (tree type
, tree late_return_type
)
22018 if (late_return_type
== NULL_TREE
)
22020 argvec
= make_tree_vec (1);
22021 TREE_VEC_ELT (argvec
, 0) = late_return_type
;
22022 if (processing_template_parmlist
)
22023 /* For a late-specified return type in a template type-parameter, we
22024 need to add a dummy argument level for its parmlist. */
22025 argvec
= add_to_template_args
22026 (make_tree_vec (processing_template_parmlist
), argvec
);
22027 if (current_template_parms
)
22028 argvec
= add_to_template_args (current_template_args (), argvec
);
22029 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
22032 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22033 'decltype(auto)'. */
22036 is_auto (const_tree type
)
22038 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
22039 && (TYPE_IDENTIFIER (type
) == get_identifier ("auto")
22040 || TYPE_IDENTIFIER (type
) == get_identifier ("decltype(auto)")))
22046 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22047 a use of `auto'. Returns NULL_TREE otherwise. */
22050 type_uses_auto (tree type
)
22052 return find_type_usage (type
, is_auto
);
22055 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22056 'decltype(auto)' or a concept. */
22059 is_auto_or_concept (const_tree type
)
22061 return is_auto (type
); // or concept
22064 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22065 a concept identifier) iff TYPE contains a use of a generic type. Returns
22066 NULL_TREE otherwise. */
22069 type_uses_auto_or_concept (tree type
)
22071 return find_type_usage (type
, is_auto_or_concept
);
22075 /* For a given template T, return the vector of typedefs referenced
22076 in T for which access check is needed at T instantiation time.
22077 T is either a FUNCTION_DECL or a RECORD_TYPE.
22078 Those typedefs were added to T by the function
22079 append_type_to_template_for_access_check. */
22081 vec
<qualified_typedef_usage_t
, va_gc
> *
22082 get_types_needing_access_check (tree t
)
22085 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
22087 if (!t
|| t
== error_mark_node
)
22090 if (!(ti
= get_template_info (t
)))
22093 if (CLASS_TYPE_P (t
)
22094 || TREE_CODE (t
) == FUNCTION_DECL
)
22096 if (!TI_TEMPLATE (ti
))
22099 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
22105 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22106 tied to T. That list of typedefs will be access checked at
22107 T instantiation time.
22108 T is either a FUNCTION_DECL or a RECORD_TYPE.
22109 TYPE_DECL is a TYPE_DECL node representing a typedef.
22110 SCOPE is the scope through which TYPE_DECL is accessed.
22111 LOCATION is the location of the usage point of TYPE_DECL.
22113 This function is a subroutine of
22114 append_type_to_template_for_access_check. */
22117 append_type_to_template_for_access_check_1 (tree t
,
22120 location_t location
)
22122 qualified_typedef_usage_t typedef_usage
;
22125 if (!t
|| t
== error_mark_node
)
22128 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
22129 || CLASS_TYPE_P (t
))
22131 && TREE_CODE (type_decl
) == TYPE_DECL
22134 if (!(ti
= get_template_info (t
)))
22137 gcc_assert (TI_TEMPLATE (ti
));
22139 typedef_usage
.typedef_decl
= type_decl
;
22140 typedef_usage
.context
= scope
;
22141 typedef_usage
.locus
= location
;
22143 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
22146 /* Append TYPE_DECL to the template TEMPL.
22147 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22148 At TEMPL instanciation time, TYPE_DECL will be checked to see
22149 if it can be accessed through SCOPE.
22150 LOCATION is the location of the usage point of TYPE_DECL.
22152 e.g. consider the following code snippet:
22159 template<class U> struct S
22161 C::myint mi; // <-- usage point of the typedef C::myint
22166 At S<char> instantiation time, we need to check the access of C::myint
22167 In other words, we need to check the access of the myint typedef through
22168 the C scope. For that purpose, this function will add the myint typedef
22169 and the scope C through which its being accessed to a list of typedefs
22170 tied to the template S. That list will be walked at template instantiation
22171 time and access check performed on each typedefs it contains.
22172 Note that this particular code snippet should yield an error because
22173 myint is private to C. */
22176 append_type_to_template_for_access_check (tree templ
,
22179 location_t location
)
22181 qualified_typedef_usage_t
*iter
;
22184 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
22186 /* Make sure we don't append the type to the template twice. */
22187 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
22188 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
22191 append_type_to_template_for_access_check_1 (templ
, type_decl
,
22195 /* Convert the generic type parameters in PARM that match the types given in the
22196 range [START_IDX, END_IDX) from the current_template_parms into generic type
22200 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
22202 tree current
= current_template_parms
;
22203 int depth
= TMPL_PARMS_DEPTH (current
);
22204 current
= INNERMOST_TEMPLATE_PARMS (current
);
22205 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
22207 for (int i
= 0; i
< start_idx
; ++i
)
22208 TREE_VEC_ELT (replacement
, i
)
22209 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22211 for (int i
= start_idx
; i
< end_idx
; ++i
)
22213 /* Create a distinct parameter pack type from the current parm and add it
22214 to the replacement args to tsubst below into the generic function
22217 tree o
= TREE_TYPE (TREE_VALUE
22218 (TREE_VEC_ELT (current
, i
)));
22219 tree t
= copy_type (o
);
22220 TEMPLATE_TYPE_PARM_INDEX (t
)
22221 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
22223 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
22224 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
22225 TYPE_MAIN_VARIANT (t
) = t
;
22226 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
22227 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
22228 TREE_VEC_ELT (replacement
, i
) = t
;
22229 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
22232 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
22233 TREE_VEC_ELT (replacement
, i
)
22234 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
22236 /* If there are more levels then build up the replacement with the outer
22239 replacement
= add_to_template_args (template_parms_to_args
22240 (TREE_CHAIN (current_template_parms
)),
22243 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
22247 /* Set up the hash tables for template instantiations. */
22250 init_template_processing (void)
22252 decl_specializations
= htab_create_ggc (37,
22253 hash_specialization
,
22254 eq_specializations
,
22256 type_specializations
= htab_create_ggc (37,
22257 hash_specialization
,
22258 eq_specializations
,
22262 /* Print stats about the template hash tables for -fstats. */
22265 print_template_statistics (void)
22267 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
22268 "%f collisions\n", (long) htab_size (decl_specializations
),
22269 (long) htab_elements (decl_specializations
),
22270 htab_collisions (decl_specializations
));
22271 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
22272 "%f collisions\n", (long) htab_size (type_specializations
),
22273 (long) htab_elements (type_specializations
),
22274 htab_collisions (type_specializations
));
22277 #include "gt-cp-pt.h"