1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
31 #include "coretypes.h"
35 #include "pointer-set.h"
39 #include "cp-objcp-common.h"
40 #include "tree-inline.h"
47 #include "tree-iterator.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 The TREE_PURPOSE of each entry is either a DECL (for a function or
58 static data member), or a TYPE (for a class) indicating what we are
59 hoping to instantiate. The TREE_VALUE is not used. */
60 static GTY(()) tree pending_templates
;
61 static GTY(()) tree last_pending_template
;
63 int processing_template_parmlist
;
64 static int template_header_count
;
66 static GTY(()) tree saved_trees
;
67 static VEC(int,heap
) *inline_parm_levels
;
69 static GTY(()) tree current_tinst_level
;
71 static GTY(()) tree saved_access_scope
;
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76 static tree cur_stmt_expr
;
78 /* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
81 static htab_t local_specializations
;
83 /* Contains canonical template parameter types. The vector is indexed by
84 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
85 TREE_LIST, whose TREE_VALUEs contain the canonical template
86 parameters of various types and levels. */
87 static GTY(()) VEC(tree
,gc
) *canonical_template_parms
;
89 #define UNIFY_ALLOW_NONE 0
90 #define UNIFY_ALLOW_MORE_CV_QUAL 1
91 #define UNIFY_ALLOW_LESS_CV_QUAL 2
92 #define UNIFY_ALLOW_DERIVED 4
93 #define UNIFY_ALLOW_INTEGER 8
94 #define UNIFY_ALLOW_OUTER_LEVEL 16
95 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
96 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
98 static void push_access_scope (tree
);
99 static void pop_access_scope (tree
);
100 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
101 unification_kind_t
, int);
102 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
103 unification_kind_t
, int, bool);
104 static int unify (tree
, tree
, tree
, tree
, int);
105 static void add_pending_template (tree
);
106 static int push_tinst_level (tree
);
107 static void pop_tinst_level (void);
108 static void reopen_tinst_level (tree
);
109 static tree
tsubst_initializer_list (tree
, tree
);
110 static tree
get_class_bindings (tree
, tree
, tree
);
111 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
113 static void tsubst_enum (tree
, tree
, tree
);
114 static tree
add_to_template_args (tree
, tree
);
115 static tree
add_outermost_template_args (tree
, tree
);
116 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
117 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
119 static int type_unification_real (tree
, tree
, tree
, tree
,
120 int, unification_kind_t
, int);
121 static void note_template_header (int);
122 static tree
convert_nontype_argument_function (tree
, tree
);
123 static tree
convert_nontype_argument (tree
, tree
);
124 static tree
convert_template_argument (tree
, tree
, tree
,
125 tsubst_flags_t
, int, tree
);
126 static int for_each_template_parm (tree
, tree_fn_t
, void*,
127 struct pointer_set_t
*);
128 static tree
expand_template_argument_pack (tree
);
129 static tree
build_template_parm_index (int, int, int, tree
, tree
);
130 static int inline_needs_template_parms (tree
);
131 static void push_inline_template_parms_recursive (tree
, int);
132 static tree
retrieve_local_specialization (tree
);
133 static void register_local_specialization (tree
, tree
);
134 static tree
reduce_template_parm_level (tree
, tree
, int);
135 static int mark_template_parm (tree
, void *);
136 static int template_parm_this_level_p (tree
, void *);
137 static tree
tsubst_friend_function (tree
, tree
);
138 static tree
tsubst_friend_class (tree
, tree
);
139 static int can_complete_type_without_circularity (tree
);
140 static tree
get_bindings (tree
, tree
, tree
, bool);
141 static int template_decl_level (tree
);
142 static int check_cv_quals_for_unify (int, tree
, tree
);
143 static void template_parm_level_and_index (tree
, int*, int*);
144 static int unify_pack_expansion (tree
, tree
, tree
, tree
, int, bool, bool);
145 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
146 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
147 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
148 static void regenerate_decl_from_template (tree
, tree
);
149 static tree
most_specialized_class (tree
, tree
);
150 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
151 static tree
tsubst_arg_types (tree
, tree
, tsubst_flags_t
, tree
);
152 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
153 static bool check_specialization_scope (void);
154 static tree
process_partial_specialization (tree
);
155 static void set_current_access_from_decl (tree
);
156 static tree
get_template_base (tree
, tree
, tree
, tree
);
157 static tree
try_class_unification (tree
, tree
, tree
, tree
);
158 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
160 static int template_args_equal (tree
, tree
);
161 static void tsubst_default_arguments (tree
);
162 static tree
for_each_template_parm_r (tree
*, int *, void *);
163 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
164 static void copy_default_args_to_explicit_spec (tree
);
165 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
166 static int eq_local_specializations (const void *, const void *);
167 static bool dependent_template_arg_p (tree
);
168 static bool any_template_arguments_need_structural_equality_p (tree
);
169 static bool dependent_type_p_r (tree
);
170 static tree
tsubst (tree
, tree
, tsubst_flags_t
, tree
);
171 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
172 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
173 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
175 /* Make the current scope suitable for access checking when we are
176 processing T. T can be FUNCTION_DECL for instantiated function
177 template, or VAR_DECL for static member variable (need by
178 instantiate_decl). */
181 push_access_scope (tree t
)
183 gcc_assert (TREE_CODE (t
) == FUNCTION_DECL
184 || TREE_CODE (t
) == VAR_DECL
);
186 if (DECL_FRIEND_CONTEXT (t
))
187 push_nested_class (DECL_FRIEND_CONTEXT (t
));
188 else if (DECL_CLASS_SCOPE_P (t
))
189 push_nested_class (DECL_CONTEXT (t
));
191 push_to_top_level ();
193 if (TREE_CODE (t
) == FUNCTION_DECL
)
195 saved_access_scope
= tree_cons
196 (NULL_TREE
, current_function_decl
, saved_access_scope
);
197 current_function_decl
= t
;
201 /* Restore the scope set up by push_access_scope. T is the node we
205 pop_access_scope (tree t
)
207 if (TREE_CODE (t
) == FUNCTION_DECL
)
209 current_function_decl
= TREE_VALUE (saved_access_scope
);
210 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
213 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
216 pop_from_top_level ();
219 /* Do any processing required when DECL (a member template
220 declaration) is finished. Returns the TEMPLATE_DECL corresponding
221 to DECL, unless it is a specialization, in which case the DECL
222 itself is returned. */
225 finish_member_template_decl (tree decl
)
227 if (decl
== error_mark_node
)
228 return error_mark_node
;
230 gcc_assert (DECL_P (decl
));
232 if (TREE_CODE (decl
) == TYPE_DECL
)
236 type
= TREE_TYPE (decl
);
237 if (IS_AGGR_TYPE (type
)
238 && CLASSTYPE_TEMPLATE_INFO (type
)
239 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
241 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
242 check_member_template (tmpl
);
247 else if (TREE_CODE (decl
) == FIELD_DECL
)
248 error ("data member %qD cannot be a member template", decl
);
249 else if (DECL_TEMPLATE_INFO (decl
))
251 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
253 check_member_template (DECL_TI_TEMPLATE (decl
));
254 return DECL_TI_TEMPLATE (decl
);
260 error ("invalid member template declaration %qD", decl
);
262 return error_mark_node
;
265 /* Returns the template nesting level of the indicated class TYPE.
275 A<T>::B<U> has depth two, while A<T> has depth one.
276 Both A<T>::B<int> and A<int>::B<U> have depth one, if
277 they are instantiations, not specializations.
279 This function is guaranteed to return 0 if passed NULL_TREE so
280 that, for example, `template_class_depth (current_class_type)' is
284 template_class_depth (tree type
)
289 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
290 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
291 ? CP_DECL_CONTEXT (type
) : TYPE_CONTEXT (type
))
293 if (TREE_CODE (type
) != FUNCTION_DECL
)
295 if (CLASSTYPE_TEMPLATE_INFO (type
)
296 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
))
297 && uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
302 if (DECL_TEMPLATE_INFO (type
)
303 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type
))
304 && uses_template_parms (DECL_TI_ARGS (type
)))
312 /* Returns 1 if processing DECL as part of do_pending_inlines
313 needs us to push template parms. */
316 inline_needs_template_parms (tree decl
)
318 if (! DECL_TEMPLATE_INFO (decl
))
321 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
322 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
325 /* Subroutine of maybe_begin_member_template_processing.
326 Push the template parms in PARMS, starting from LEVELS steps into the
327 chain, and ending at the beginning, since template parms are listed
331 push_inline_template_parms_recursive (tree parmlist
, int levels
)
333 tree parms
= TREE_VALUE (parmlist
);
337 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
339 ++processing_template_decl
;
340 current_template_parms
341 = tree_cons (size_int (processing_template_decl
),
342 parms
, current_template_parms
);
343 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
345 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
347 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
349 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
351 if (parm
== error_mark_node
)
354 gcc_assert (DECL_P (parm
));
356 switch (TREE_CODE (parm
))
365 /* Make a CONST_DECL as is done in process_template_parm.
366 It is ugly that we recreate this here; the original
367 version built in process_template_parm is no longer
369 tree decl
= build_decl (CONST_DECL
, DECL_NAME (parm
),
371 DECL_ARTIFICIAL (decl
) = 1;
372 TREE_CONSTANT (decl
) = 1;
373 TREE_INVARIANT (decl
) = 1;
374 TREE_READONLY (decl
) = 1;
375 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
376 SET_DECL_TEMPLATE_PARM_P (decl
);
387 /* Restore the template parameter context for a member template or
388 a friend template defined in a class definition. */
391 maybe_begin_member_template_processing (tree decl
)
396 if (inline_needs_template_parms (decl
))
398 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
399 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
401 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
404 parms
= TREE_CHAIN (parms
);
407 push_inline_template_parms_recursive (parms
, levels
);
410 /* Remember how many levels of template parameters we pushed so that
411 we can pop them later. */
412 VEC_safe_push (int, heap
, inline_parm_levels
, levels
);
415 /* Undo the effects of maybe_begin_member_template_processing. */
418 maybe_end_member_template_processing (void)
423 if (VEC_length (int, inline_parm_levels
) == 0)
426 last
= VEC_pop (int, inline_parm_levels
);
427 for (i
= 0; i
< last
; ++i
)
429 --processing_template_decl
;
430 current_template_parms
= TREE_CHAIN (current_template_parms
);
435 /* Return a new template argument vector which contains all of ARGS,
436 but has as its innermost set of arguments the EXTRA_ARGS. */
439 add_to_template_args (tree args
, tree extra_args
)
446 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
447 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
449 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
450 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
452 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
453 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
458 /* Like add_to_template_args, but only the outermost ARGS are added to
459 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
460 (EXTRA_ARGS) levels are added. This function is used to combine
461 the template arguments from a partial instantiation with the
462 template arguments used to attain the full instantiation from the
463 partial instantiation. */
466 add_outermost_template_args (tree args
, tree extra_args
)
470 /* If there are more levels of EXTRA_ARGS than there are ARGS,
471 something very fishy is going on. */
472 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
474 /* If *all* the new arguments will be the EXTRA_ARGS, just return
476 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
479 /* For the moment, we make ARGS look like it contains fewer levels. */
480 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
482 new_args
= add_to_template_args (args
, extra_args
);
484 /* Now, we restore ARGS to its full dimensions. */
485 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
490 /* Return the N levels of innermost template arguments from the ARGS. */
493 get_innermost_template_args (tree args
, int n
)
501 /* If N is 1, just return the innermost set of template arguments. */
503 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
505 /* If we're not removing anything, just return the arguments we were
507 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
508 gcc_assert (extra_levels
>= 0);
509 if (extra_levels
== 0)
512 /* Make a new set of arguments, not containing the outer arguments. */
513 new_args
= make_tree_vec (n
);
514 for (i
= 1; i
<= n
; ++i
)
515 SET_TMPL_ARGS_LEVEL (new_args
, i
,
516 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
521 /* We've got a template header coming up; push to a new level for storing
525 begin_template_parm_list (void)
527 /* We use a non-tag-transparent scope here, which causes pushtag to
528 put tags in this scope, rather than in the enclosing class or
529 namespace scope. This is the right thing, since we want
530 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
531 global template class, push_template_decl handles putting the
532 TEMPLATE_DECL into top-level scope. For a nested template class,
535 template <class T> struct S1 {
536 template <class T> struct S2 {};
539 pushtag contains special code to call pushdecl_with_scope on the
540 TEMPLATE_DECL for S2. */
541 begin_scope (sk_template_parms
, NULL
);
542 ++processing_template_decl
;
543 ++processing_template_parmlist
;
544 note_template_header (0);
547 /* This routine is called when a specialization is declared. If it is
548 invalid to declare a specialization here, an error is reported and
549 false is returned, otherwise this routine will return true. */
552 check_specialization_scope (void)
554 tree scope
= current_scope ();
558 An explicit specialization shall be declared in the namespace of
559 which the template is a member, or, for member templates, in the
560 namespace of which the enclosing class or enclosing class
561 template is a member. An explicit specialization of a member
562 function, member class or static data member of a class template
563 shall be declared in the namespace of which the class template
565 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
567 error ("explicit specialization in non-namespace scope %qD", scope
);
573 In an explicit specialization declaration for a member of a class
574 template or a member template that appears in namespace scope,
575 the member template and some of its enclosing class templates may
576 remain unspecialized, except that the declaration shall not
577 explicitly specialize a class member template if its enclosing
578 class templates are not explicitly specialized as well. */
579 if (current_template_parms
)
581 error ("enclosing class templates are not explicitly specialized");
588 /* We've just seen template <>. */
591 begin_specialization (void)
593 begin_scope (sk_template_spec
, NULL
);
594 note_template_header (1);
595 return check_specialization_scope ();
598 /* Called at then end of processing a declaration preceded by
602 end_specialization (void)
605 reset_specialization ();
608 /* Any template <>'s that we have seen thus far are not referring to a
609 function specialization. */
612 reset_specialization (void)
614 processing_specialization
= 0;
615 template_header_count
= 0;
618 /* We've just seen a template header. If SPECIALIZATION is nonzero,
619 it was of the form template <>. */
622 note_template_header (int specialization
)
624 processing_specialization
= specialization
;
625 template_header_count
++;
628 /* We're beginning an explicit instantiation. */
631 begin_explicit_instantiation (void)
633 gcc_assert (!processing_explicit_instantiation
);
634 processing_explicit_instantiation
= true;
639 end_explicit_instantiation (void)
641 gcc_assert (processing_explicit_instantiation
);
642 processing_explicit_instantiation
= false;
645 /* An explicit specialization or partial specialization TMPL is being
646 declared. Check that the namespace in which the specialization is
647 occurring is permissible. Returns false iff it is invalid to
648 specialize TMPL in the current namespace. */
651 check_specialization_namespace (tree tmpl
)
653 tree tpl_ns
= decl_namespace_context (tmpl
);
657 An explicit specialization shall be declared in the namespace of
658 which the template is a member, or, for member templates, in the
659 namespace of which the enclosing class or enclosing class
660 template is a member. An explicit specialization of a member
661 function, member class or static data member of a class template
662 shall be declared in the namespace of which the class template is
664 if (is_associated_namespace (current_namespace
, tpl_ns
))
665 /* Same or super-using namespace. */
669 pedwarn ("specialization of %qD in different namespace", tmpl
);
670 pedwarn (" from definition of %q+#D", tmpl
);
675 /* SPEC is an explicit instantiation. Check that it is valid to
676 perform this explicit instantiation in the current namespace. */
679 check_explicit_instantiation_namespace (tree spec
)
683 /* DR 275: An explicit instantiation shall appear in an enclosing
684 namespace of its template. */
685 ns
= decl_namespace_context (spec
);
686 if (!is_ancestor (current_namespace
, ns
))
687 pedwarn ("explicit instantiation of %qD in namespace %qD "
688 "(which does not enclose namespace %qD)",
689 spec
, current_namespace
, ns
);
692 /* The TYPE is being declared. If it is a template type, that means it
693 is a partial specialization. Do appropriate error-checking. */
696 maybe_process_partial_specialization (tree type
)
700 if (type
== error_mark_node
)
701 return error_mark_node
;
703 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
705 error ("name of class shadows template template parameter %qD",
707 return error_mark_node
;
710 context
= TYPE_CONTEXT (type
);
712 if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
714 /* This is for ordinary explicit specialization and partial
715 specialization of a template class such as:
717 template <> class C<int>;
721 template <class T> class C<T*>;
723 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
725 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
726 && !COMPLETE_TYPE_P (type
))
728 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
));
729 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
730 if (processing_template_decl
)
731 push_template_decl (TYPE_MAIN_DECL (type
));
733 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
734 error ("specialization of %qT after instantiation", type
);
736 else if (CLASS_TYPE_P (type
)
737 && !CLASSTYPE_USE_TEMPLATE (type
)
738 && CLASSTYPE_TEMPLATE_INFO (type
)
739 && context
&& CLASS_TYPE_P (context
)
740 && CLASSTYPE_TEMPLATE_INFO (context
))
742 /* This is for an explicit specialization of member class
743 template according to [temp.expl.spec/18]:
745 template <> template <class U> class C<int>::D;
747 The context `C<int>' must be an implicit instantiation.
748 Otherwise this is just a member class template declared
751 template <> class C<int> { template <class U> class D; };
752 template <> template <class U> class C<int>::D;
754 In the first case, `C<int>::D' is a specialization of `C<T>::D'
755 while in the second case, `C<int>::D' is a primary template
756 and `C<T>::D' may not exist. */
758 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
759 && !COMPLETE_TYPE_P (type
))
763 if (current_namespace
764 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type
)))
766 pedwarn ("specializing %q#T in different namespace", type
);
767 pedwarn (" from definition of %q+#D",
768 CLASSTYPE_TI_TEMPLATE (type
));
771 /* Check for invalid specialization after instantiation:
773 template <> template <> class C<int>::D<int>;
774 template <> template <class U> class C<int>::D; */
776 for (t
= DECL_TEMPLATE_INSTANTIATIONS
777 (most_general_template (CLASSTYPE_TI_TEMPLATE (type
)));
778 t
; t
= TREE_CHAIN (t
))
779 if (TREE_VALUE (t
) != type
780 && TYPE_CONTEXT (TREE_VALUE (t
)) == context
)
781 error ("specialization %qT after instantiation %qT",
782 type
, TREE_VALUE (t
));
784 /* Mark TYPE as a specialization. And as a result, we only
785 have one level of template argument for the innermost
787 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
788 CLASSTYPE_TI_ARGS (type
)
789 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
792 else if (processing_specialization
)
794 error ("explicit specialization of non-template %qT", type
);
795 return error_mark_node
;
801 /* Returns nonzero if we can optimize the retrieval of specializations
802 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
803 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
806 optimize_specialization_lookup_p (tree tmpl
)
808 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
809 && DECL_CLASS_SCOPE_P (tmpl
)
810 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
812 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
813 /* The optimized lookup depends on the fact that the
814 template arguments for the member function template apply
815 purely to the containing class, which is not true if the
816 containing class is an explicit or partial
818 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
819 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
820 && !DECL_CONV_FN_P (tmpl
)
821 /* It is possible to have a template that is not a member
822 template and is not a member of a template class:
824 template <typename T>
825 struct S { friend A::f(); };
827 Here, the friend function is a template, but the context does
828 not have template information. The optimized lookup relies
829 on having ARGS be the template arguments for both the class
830 and the function template. */
831 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
834 /* Retrieve the specialization (in the sense of [temp.spec] - a
835 specialization is either an instantiation or an explicit
836 specialization) of TMPL for the given template ARGS. If there is
837 no such specialization, return NULL_TREE. The ARGS are a vector of
838 arguments, or a vector of vectors of arguments, in the case of
839 templates with more than one level of parameters.
841 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
842 then we search for a partial specialization matching ARGS. This
843 parameter is ignored if TMPL is not a class template. */
846 retrieve_specialization (tree tmpl
, tree args
,
847 bool class_specializations_p
)
849 if (args
== error_mark_node
)
852 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
854 /* There should be as many levels of arguments as there are
855 levels of parameters. */
856 gcc_assert (TMPL_ARGS_DEPTH (args
)
857 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
859 if (optimize_specialization_lookup_p (tmpl
))
862 tree class_specialization
;
863 VEC(tree
,gc
) *methods
;
867 /* The template arguments actually apply to the containing
868 class. Find the class specialization with those
870 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
872 = retrieve_specialization (class_template
, args
,
873 /*class_specializations_p=*/false);
874 if (!class_specialization
)
876 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
877 for the specialization. */
878 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
881 /* Iterate through the methods with the indicated name, looking
882 for the one that has an instance of TMPL. */
883 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
884 for (fns
= VEC_index (tree
, methods
, idx
); fns
; fns
= OVL_NEXT (fns
))
886 tree fn
= OVL_CURRENT (fns
);
887 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
)
897 /* Class templates store their instantiations on the
898 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
899 DECL_TEMPLATE_SPECIALIZATIONS list. */
900 if (!class_specializations_p
901 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl
)) == TYPE_DECL
)
902 sp
= &DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
904 sp
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
906 /* Iterate through the list until we find a matching template. */
907 while (*sp
!= NULL_TREE
)
911 if (comp_template_args (TREE_PURPOSE (spec
), args
))
913 /* Use the move-to-front heuristic to speed up future
917 *sp
= TREE_CHAIN (*sp
);
918 TREE_CHAIN (spec
) = *head
;
921 return TREE_VALUE (spec
);
923 sp
= &TREE_CHAIN (spec
);
930 /* Like retrieve_specialization, but for local declarations. */
933 retrieve_local_specialization (tree tmpl
)
935 tree spec
= (tree
) htab_find_with_hash (local_specializations
, tmpl
,
936 htab_hash_pointer (tmpl
));
937 return spec
? TREE_PURPOSE (spec
) : NULL_TREE
;
940 /* Returns nonzero iff DECL is a specialization of TMPL. */
943 is_specialization_of (tree decl
, tree tmpl
)
947 if (TREE_CODE (decl
) == FUNCTION_DECL
)
951 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
957 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
959 for (t
= TREE_TYPE (decl
);
961 t
= CLASSTYPE_USE_TEMPLATE (t
)
962 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
963 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
970 /* Returns nonzero iff DECL is a specialization of friend declaration
971 FRIEND according to [temp.friend]. */
974 is_specialization_of_friend (tree decl
, tree
friend)
976 bool need_template
= true;
979 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
980 || TREE_CODE (decl
) == TYPE_DECL
);
982 /* For [temp.friend/6] when FRIEND is an ordinary member function
983 of a template class, we want to check if DECL is a specialization
985 if (TREE_CODE (friend) == FUNCTION_DECL
986 && DECL_TEMPLATE_INFO (friend)
987 && !DECL_USE_TEMPLATE (friend))
989 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
990 friend = DECL_TI_TEMPLATE (friend);
991 need_template
= false;
993 else if (TREE_CODE (friend) == TEMPLATE_DECL
994 && !PRIMARY_TEMPLATE_P (friend))
995 need_template
= false;
997 /* There is nothing to do if this is not a template friend. */
998 if (TREE_CODE (friend) != TEMPLATE_DECL
)
1001 if (is_specialization_of (decl
, friend))
1005 A member of a class template may be declared to be a friend of a
1006 non-template class. In this case, the corresponding member of
1007 every specialization of the class template is a friend of the
1008 class granting friendship.
1010 For example, given a template friend declaration
1012 template <class T> friend void A<T>::f();
1014 the member function below is considered a friend
1016 template <> struct A<int> {
1020 For this type of template friend, TEMPLATE_DEPTH below will be
1021 nonzero. To determine if DECL is a friend of FRIEND, we first
1022 check if the enclosing class is a specialization of another. */
1024 template_depth
= template_class_depth (DECL_CONTEXT (friend));
1026 && DECL_CLASS_SCOPE_P (decl
)
1027 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1028 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1030 /* Next, we check the members themselves. In order to handle
1031 a few tricky cases, such as when FRIEND's are
1033 template <class T> friend void A<T>::g(T t);
1034 template <class T> template <T t> friend void A<T>::h();
1038 void A<int>::g(int);
1039 template <int> void A<int>::h();
1041 we need to figure out ARGS, the template arguments from
1042 the context of DECL. This is required for template substitution
1043 of `T' in the function parameter of `g' and template parameter
1044 of `h' in the above examples. Here ARGS corresponds to `int'. */
1046 tree context
= DECL_CONTEXT (decl
);
1047 tree args
= NULL_TREE
;
1048 int current_depth
= 0;
1050 while (current_depth
< template_depth
)
1052 if (CLASSTYPE_TEMPLATE_INFO (context
))
1054 if (current_depth
== 0)
1055 args
= TYPE_TI_ARGS (context
);
1057 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1060 context
= TYPE_CONTEXT (context
);
1063 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1068 tree friend_args_type
;
1069 tree decl_args_type
;
1071 /* Make sure that both DECL and FRIEND are templates or
1073 is_template
= DECL_TEMPLATE_INFO (decl
)
1074 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1075 if (need_template
^ is_template
)
1077 else if (is_template
)
1079 /* If both are templates, check template parameter list. */
1081 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1083 if (!comp_template_parms
1084 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1088 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1091 decl_type
= TREE_TYPE (decl
);
1093 friend_type
= tsubst_function_type (TREE_TYPE (friend), args
,
1094 tf_none
, NULL_TREE
);
1095 if (friend_type
== error_mark_node
)
1098 /* Check if return types match. */
1099 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1102 /* Check if function parameter types match, ignoring the
1103 `this' parameter. */
1104 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1105 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1106 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1107 friend_args_type
= TREE_CHAIN (friend_args_type
);
1108 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1109 decl_args_type
= TREE_CHAIN (decl_args_type
);
1111 return compparms (decl_args_type
, friend_args_type
);
1115 /* DECL is a TYPE_DECL */
1117 tree decl_type
= TREE_TYPE (decl
);
1119 /* Make sure that both DECL and FRIEND are templates or
1122 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1123 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1125 if (need_template
^ is_template
)
1127 else if (is_template
)
1130 /* If both are templates, check the name of the two
1131 TEMPLATE_DECL's first because is_friend didn't. */
1132 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1133 != DECL_NAME (friend))
1136 /* Now check template parameter list. */
1138 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1140 return comp_template_parms
1141 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1145 return (DECL_NAME (decl
)
1146 == DECL_NAME (friend));
1152 /* Register the specialization SPEC as a specialization of TMPL with
1153 the indicated ARGS. IS_FRIEND indicates whether the specialization
1154 is actually just a friend declaration. Returns SPEC, or an
1155 equivalent prior declaration, if available. */
1158 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
)
1162 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1164 if (TREE_CODE (spec
) == FUNCTION_DECL
1165 && uses_template_parms (DECL_TI_ARGS (spec
)))
1166 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1167 register it; we want the corresponding TEMPLATE_DECL instead.
1168 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1169 the more obvious `uses_template_parms (spec)' to avoid problems
1170 with default function arguments. In particular, given
1171 something like this:
1173 template <class T> void f(T t1, T t = T())
1175 the default argument expression is not substituted for in an
1176 instantiation unless and until it is actually needed. */
1179 fn
= retrieve_specialization (tmpl
, args
,
1180 /*class_specializations_p=*/false);
1181 /* We can sometimes try to re-register a specialization that we've
1182 already got. In particular, regenerate_decl_from_template calls
1183 duplicate_decls which will update the specialization list. But,
1184 we'll still get called again here anyhow. It's more convenient
1185 to simply allow this than to try to prevent it. */
1188 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1190 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1193 || DECL_EXPLICIT_INSTANTIATION (fn
))
1195 error ("specialization of %qD after instantiation",
1197 return error_mark_node
;
1202 /* This situation should occur only if the first
1203 specialization is an implicit instantiation, the
1204 second is an explicit specialization, and the
1205 implicit instantiation has not yet been used. That
1206 situation can occur if we have implicitly
1207 instantiated a member function and then specialized
1210 We can also wind up here if a friend declaration that
1211 looked like an instantiation turns out to be a
1214 template <class T> void foo(T);
1215 class S { friend void foo<>(int) };
1216 template <> void foo(int);
1218 We transform the existing DECL in place so that any
1219 pointers to it become pointers to the updated
1222 If there was a definition for the template, but not
1223 for the specialization, we want this to look as if
1224 there were no definition, and vice versa. */
1225 DECL_INITIAL (fn
) = NULL_TREE
;
1226 duplicate_decls (spec
, fn
, is_friend
);
1227 /* The call to duplicate_decls will have applied
1230 An explicit specialization of a function template
1231 is inline only if it is explicitly declared to be,
1232 and independently of whether its function template
1235 to the primary function; now copy the inline bits to
1236 the various clones. */
1237 FOR_EACH_CLONE (clone
, fn
)
1239 DECL_DECLARED_INLINE_P (clone
)
1240 = DECL_DECLARED_INLINE_P (fn
);
1244 check_specialization_namespace (fn
);
1249 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1251 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1252 /* Dup decl failed, but this is a new definition. Set the
1253 line number so any errors match this new
1255 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1261 /* A specialization must be declared in the same namespace as the
1262 template it is specializing. */
1263 if (DECL_TEMPLATE_SPECIALIZATION (spec
)
1264 && !check_specialization_namespace (tmpl
))
1265 DECL_CONTEXT (spec
) = FROB_CONTEXT (decl_namespace_context (tmpl
));
1267 if (!optimize_specialization_lookup_p (tmpl
))
1268 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
1269 = tree_cons (args
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
1274 /* Unregister the specialization SPEC as a specialization of TMPL.
1275 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1276 if the SPEC was listed as a specialization of TMPL. */
1279 reregister_specialization (tree spec
, tree tmpl
, tree new_spec
)
1283 for (s
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
1285 s
= &TREE_CHAIN (*s
))
1286 if (TREE_VALUE (*s
) == spec
)
1289 *s
= TREE_CHAIN (*s
);
1291 TREE_VALUE (*s
) = new_spec
;
1298 /* Compare an entry in the local specializations hash table P1 (which
1299 is really a pointer to a TREE_LIST) with P2 (which is really a
1303 eq_local_specializations (const void *p1
, const void *p2
)
1305 return TREE_VALUE ((const_tree
) p1
) == (const_tree
) p2
;
1308 /* Hash P1, an entry in the local specializations table. */
1311 hash_local_specialization (const void* p1
)
1313 return htab_hash_pointer (TREE_VALUE ((const_tree
) p1
));
1316 /* Like register_specialization, but for local declarations. We are
1317 registering SPEC, an instantiation of TMPL. */
1320 register_local_specialization (tree spec
, tree tmpl
)
1324 slot
= htab_find_slot_with_hash (local_specializations
, tmpl
,
1325 htab_hash_pointer (tmpl
), INSERT
);
1326 *slot
= build_tree_list (spec
, tmpl
);
1329 /* TYPE is a class type. Returns true if TYPE is an explicitly
1330 specialized class. */
1333 explicit_class_specialization_p (tree type
)
1335 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1337 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1340 /* Print the list of candidate FNS in an error message. */
1343 print_candidates (tree fns
)
1347 const char *str
= "candidates are:";
1349 for (fn
= fns
; fn
!= NULL_TREE
; fn
= TREE_CHAIN (fn
))
1353 for (f
= TREE_VALUE (fn
); f
; f
= OVL_NEXT (f
))
1354 error ("%s %+#D", str
, OVL_CURRENT (f
));
1359 /* Returns the template (one of the functions given by TEMPLATE_ID)
1360 which can be specialized to match the indicated DECL with the
1361 explicit template args given in TEMPLATE_ID. The DECL may be
1362 NULL_TREE if none is available. In that case, the functions in
1363 TEMPLATE_ID are non-members.
1365 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1366 specialization of a member template.
1368 The TEMPLATE_COUNT is the number of references to qualifying
1369 template classes that appeared in the name of the function. See
1370 check_explicit_specialization for a more accurate description.
1372 TSK indicates what kind of template declaration (if any) is being
1373 declared. TSK_TEMPLATE indicates that the declaration given by
1374 DECL, though a FUNCTION_DECL, has template parameters, and is
1375 therefore a template function.
1377 The template args (those explicitly specified and those deduced)
1378 are output in a newly created vector *TARGS_OUT.
1380 If it is impossible to determine the result, an error message is
1381 issued. The error_mark_node is returned to indicate failure. */
1384 determine_specialization (tree template_id
,
1387 int need_member_template
,
1393 tree explicit_targs
;
1394 tree candidates
= NULL_TREE
;
1395 /* A TREE_LIST of templates of which DECL may be a specialization.
1396 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1397 corresponding TREE_PURPOSE is the set of template arguments that,
1398 when used to instantiate the template, would produce a function
1399 with the signature of DECL. */
1400 tree templates
= NULL_TREE
;
1402 struct cp_binding_level
*b
;
1404 *targs_out
= NULL_TREE
;
1406 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1407 return error_mark_node
;
1409 fns
= TREE_OPERAND (template_id
, 0);
1410 explicit_targs
= TREE_OPERAND (template_id
, 1);
1412 if (fns
== error_mark_node
)
1413 return error_mark_node
;
1415 /* Check for baselinks. */
1416 if (BASELINK_P (fns
))
1417 fns
= BASELINK_FUNCTIONS (fns
);
1419 if (!is_overloaded_fn (fns
))
1421 error ("%qD is not a function template", fns
);
1422 return error_mark_node
;
1425 /* Count the number of template headers specified for this
1428 for (b
= current_binding_level
;
1429 b
->kind
== sk_template_parms
;
1433 for (; fns
; fns
= OVL_NEXT (fns
))
1435 tree fn
= OVL_CURRENT (fns
);
1437 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1439 tree decl_arg_types
;
1442 /* In case of explicit specialization, we need to check if
1443 the number of template headers appearing in the specialization
1444 is correct. This is usually done in check_explicit_specialization,
1445 but the check done there cannot be exhaustive when specializing
1446 member functions. Consider the following code:
1448 template <> void A<int>::f(int);
1449 template <> template <> void A<int>::f(int);
1451 Assuming that A<int> is not itself an explicit specialization
1452 already, the first line specializes "f" which is a non-template
1453 member function, whilst the second line specializes "f" which
1454 is a template member function. So both lines are syntactically
1455 correct, and check_explicit_specialization does not reject
1458 Here, we can do better, as we are matching the specialization
1459 against the declarations. We count the number of template
1460 headers, and we check if they match TEMPLATE_COUNT + 1
1461 (TEMPLATE_COUNT is the number of qualifying template classes,
1462 plus there must be another header for the member template
1465 Notice that if header_count is zero, this is not a
1466 specialization but rather a template instantiation, so there
1467 is no check we can perform here. */
1468 if (header_count
&& header_count
!= template_count
+ 1)
1471 /* Check that the number of template arguments at the
1472 innermost level for DECL is the same as for FN. */
1473 if (current_binding_level
->kind
== sk_template_parms
1474 && !current_binding_level
->explicit_spec_p
1475 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1476 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1477 (current_template_parms
))))
1480 /* DECL might be a specialization of FN. */
1481 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1482 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1484 /* For a non-static member function, we need to make sure
1485 that the const qualification is the same. Since
1486 get_bindings does not try to merge the "this" parameter,
1487 we must do the comparison explicitly. */
1488 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1489 && !same_type_p (TREE_VALUE (fn_arg_types
),
1490 TREE_VALUE (decl_arg_types
)))
1493 /* Skip the "this" parameter and, for constructors of
1494 classes with virtual bases, the VTT parameter. A
1495 full specialization of a constructor will have a VTT
1496 parameter, but a template never will. */
1498 = skip_artificial_parms_for (decl
, decl_arg_types
);
1500 = skip_artificial_parms_for (fn
, fn_arg_types
);
1502 /* Check that the number of function parameters matches.
1504 template <class T> void f(int i = 0);
1505 template <> void f<int>();
1506 The specialization f<int> is invalid but is not caught
1507 by get_bindings below. */
1508 if (list_length (fn_arg_types
) != list_length (decl_arg_types
))
1511 /* Function templates cannot be specializations; there are
1512 no partial specializations of functions. Therefore, if
1513 the type of DECL does not match FN, there is no
1515 if (tsk
== tsk_template
)
1517 if (compparms (fn_arg_types
, decl_arg_types
))
1518 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1522 /* See whether this function might be a specialization of this
1524 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
1527 /* We cannot deduce template arguments that when used to
1528 specialize TMPL will produce DECL. */
1531 /* Save this template, and the arguments deduced. */
1532 templates
= tree_cons (targs
, fn
, templates
);
1534 else if (need_member_template
)
1535 /* FN is an ordinary member function, and we need a
1536 specialization of a member template. */
1538 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
1539 /* We can get IDENTIFIER_NODEs here in certain erroneous
1542 else if (!DECL_FUNCTION_MEMBER_P (fn
))
1543 /* This is just an ordinary non-member function. Nothing can
1544 be a specialization of that. */
1546 else if (DECL_ARTIFICIAL (fn
))
1547 /* Cannot specialize functions that are created implicitly. */
1551 tree decl_arg_types
;
1553 /* This is an ordinary member function. However, since
1554 we're here, we can assume it's enclosing class is a
1555 template class. For example,
1557 template <typename T> struct S { void f(); };
1558 template <> void S<int>::f() {}
1560 Here, S<int>::f is a non-template, but S<int> is a
1561 template class. If FN has the same type as DECL, we
1562 might be in business. */
1564 if (!DECL_TEMPLATE_INFO (fn
))
1565 /* Its enclosing class is an explicit specialization
1566 of a template class. This is not a candidate. */
1569 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
1570 TREE_TYPE (TREE_TYPE (fn
))))
1571 /* The return types differ. */
1574 /* Adjust the type of DECL in case FN is a static member. */
1575 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1576 if (DECL_STATIC_FUNCTION_P (fn
)
1577 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1578 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
1580 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1583 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1587 if (templates
&& TREE_CHAIN (templates
))
1593 It is possible for a specialization with a given function
1594 signature to be instantiated from more than one function
1595 template. In such cases, explicit specification of the
1596 template arguments must be used to uniquely identify the
1597 function template specialization being specialized.
1599 Note that here, there's no suggestion that we're supposed to
1600 determine which of the candidate templates is most
1601 specialized. However, we, also have:
1605 Partial ordering of overloaded function template
1606 declarations is used in the following contexts to select
1607 the function template to which a function template
1608 specialization refers:
1610 -- when an explicit specialization refers to a function
1613 So, we do use the partial ordering rules, at least for now.
1614 This extension can only serve to make invalid programs valid,
1615 so it's safe. And, there is strong anecdotal evidence that
1616 the committee intended the partial ordering rules to apply;
1617 the EDG front end has that behavior, and John Spicer claims
1618 that the committee simply forgot to delete the wording in
1619 [temp.expl.spec]. */
1620 tree tmpl
= most_specialized_instantiation (templates
);
1621 if (tmpl
!= error_mark_node
)
1624 TREE_CHAIN (templates
) = NULL_TREE
;
1628 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
1630 error ("template-id %qD for %q+D does not match any template "
1631 "declaration", template_id
, decl
);
1632 return error_mark_node
;
1634 else if ((templates
&& TREE_CHAIN (templates
))
1635 || (candidates
&& TREE_CHAIN (candidates
))
1636 || (templates
&& candidates
))
1638 error ("ambiguous template specialization %qD for %q+D",
1640 chainon (candidates
, templates
);
1641 print_candidates (candidates
);
1642 return error_mark_node
;
1645 /* We have one, and exactly one, match. */
1648 tree fn
= TREE_VALUE (candidates
);
1649 /* DECL is a re-declaration of a template function. */
1650 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1652 /* It was a specialization of an ordinary member function in a
1654 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
1655 return DECL_TI_TEMPLATE (fn
);
1658 /* It was a specialization of a template. */
1659 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
1660 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
1662 *targs_out
= copy_node (targs
);
1663 SET_TMPL_ARGS_LEVEL (*targs_out
,
1664 TMPL_ARGS_DEPTH (*targs_out
),
1665 TREE_PURPOSE (templates
));
1668 *targs_out
= TREE_PURPOSE (templates
);
1669 return TREE_VALUE (templates
);
1672 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1673 but with the default argument values filled in from those in the
1677 copy_default_args_to_explicit_spec_1 (tree spec_types
,
1680 tree new_spec_types
;
1685 if (spec_types
== void_list_node
)
1686 return void_list_node
;
1688 /* Substitute into the rest of the list. */
1690 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
1691 TREE_CHAIN (tmpl_types
));
1693 /* Add the default argument for this parameter. */
1694 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
1695 TREE_VALUE (spec_types
),
1699 /* DECL is an explicit specialization. Replicate default arguments
1700 from the template it specializes. (That way, code like:
1702 template <class T> void f(T = 3);
1703 template <> void f(double);
1706 works, as required.) An alternative approach would be to look up
1707 the correct default arguments at the call-site, but this approach
1708 is consistent with how implicit instantiations are handled. */
1711 copy_default_args_to_explicit_spec (tree decl
)
1716 tree new_spec_types
;
1720 tree object_type
= NULL_TREE
;
1721 tree in_charge
= NULL_TREE
;
1722 tree vtt
= NULL_TREE
;
1724 /* See if there's anything we need to do. */
1725 tmpl
= DECL_TI_TEMPLATE (decl
);
1726 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
1727 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
1728 if (TREE_PURPOSE (t
))
1733 old_type
= TREE_TYPE (decl
);
1734 spec_types
= TYPE_ARG_TYPES (old_type
);
1736 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1738 /* Remove the this pointer, but remember the object's type for
1740 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
1741 spec_types
= TREE_CHAIN (spec_types
);
1742 tmpl_types
= TREE_CHAIN (tmpl_types
);
1744 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
1746 /* DECL may contain more parameters than TMPL due to the extra
1747 in-charge parameter in constructors and destructors. */
1748 in_charge
= spec_types
;
1749 spec_types
= TREE_CHAIN (spec_types
);
1751 if (DECL_HAS_VTT_PARM_P (decl
))
1754 spec_types
= TREE_CHAIN (spec_types
);
1758 /* Compute the merged default arguments. */
1760 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
1762 /* Compute the new FUNCTION_TYPE. */
1766 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
1771 /* Put the in-charge parameter back. */
1772 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
1773 TREE_VALUE (in_charge
),
1776 new_type
= build_method_type_directly (object_type
,
1777 TREE_TYPE (old_type
),
1781 new_type
= build_function_type (TREE_TYPE (old_type
),
1783 new_type
= cp_build_type_attribute_variant (new_type
,
1784 TYPE_ATTRIBUTES (old_type
));
1785 new_type
= build_exception_variant (new_type
,
1786 TYPE_RAISES_EXCEPTIONS (old_type
));
1787 TREE_TYPE (decl
) = new_type
;
1790 /* Check to see if the function just declared, as indicated in
1791 DECLARATOR, and in DECL, is a specialization of a function
1792 template. We may also discover that the declaration is an explicit
1793 instantiation at this point.
1795 Returns DECL, or an equivalent declaration that should be used
1796 instead if all goes well. Issues an error message if something is
1797 amiss. Returns error_mark_node if the error is not easily
1800 FLAGS is a bitmask consisting of the following flags:
1802 2: The function has a definition.
1803 4: The function is a friend.
1805 The TEMPLATE_COUNT is the number of references to qualifying
1806 template classes that appeared in the name of the function. For
1809 template <class T> struct S { void f(); };
1812 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1813 classes are not counted in the TEMPLATE_COUNT, so that in
1815 template <class T> struct S {};
1816 template <> struct S<int> { void f(); }
1817 template <> void S<int>::f();
1819 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1820 invalid; there should be no template <>.)
1822 If the function is a specialization, it is marked as such via
1823 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1824 is set up correctly, and it is added to the list of specializations
1825 for that template. */
1828 check_explicit_specialization (tree declarator
,
1833 int have_def
= flags
& 2;
1834 int is_friend
= flags
& 4;
1835 int specialization
= 0;
1836 int explicit_instantiation
= 0;
1837 int member_specialization
= 0;
1838 tree ctype
= DECL_CLASS_CONTEXT (decl
);
1839 tree dname
= DECL_NAME (decl
);
1844 if (!processing_specialization
)
1847 tsk
= tsk_excessive_parms
;
1850 tsk
= current_tmpl_spec_kind (template_count
);
1855 if (processing_specialization
)
1858 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1860 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1863 /* This could be something like:
1865 template <class T> void f(T);
1866 class S { friend void f<>(int); } */
1870 /* This case handles bogus declarations like template <>
1871 template <class T> void f<int>(); */
1873 error ("template-id %qD in declaration of primary template",
1880 case tsk_invalid_member_spec
:
1881 /* The error has already been reported in
1882 check_specialization_scope. */
1883 return error_mark_node
;
1885 case tsk_invalid_expl_inst
:
1886 error ("template parameter list used in explicit instantiation");
1892 error ("definition provided for explicit instantiation");
1894 explicit_instantiation
= 1;
1897 case tsk_excessive_parms
:
1898 case tsk_insufficient_parms
:
1899 if (tsk
== tsk_excessive_parms
)
1900 error ("too many template parameter lists in declaration of %qD",
1902 else if (template_header_count
)
1903 error("too few template parameter lists in declaration of %qD", decl
);
1905 error("explicit specialization of %qD must be introduced by "
1906 "%<template <>%>", decl
);
1910 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1912 member_specialization
= 1;
1918 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1920 /* This case handles bogus declarations like template <>
1921 template <class T> void f<int>(); */
1923 if (uses_template_parms (declarator
))
1924 error ("function template partial specialization %qD "
1925 "is not allowed", declarator
);
1927 error ("template-id %qD in declaration of primary template",
1932 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
1933 /* This is a specialization of a member template, without
1934 specialization the containing class. Something like:
1936 template <class T> struct S {
1937 template <class U> void f (U);
1939 template <> template <class U> void S<int>::f(U) {}
1941 That's a specialization -- but of the entire template. */
1949 if (specialization
|| member_specialization
)
1951 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1952 for (; t
; t
= TREE_CHAIN (t
))
1953 if (TREE_PURPOSE (t
))
1956 ("default argument specified in explicit specialization");
1961 if (specialization
|| member_specialization
|| explicit_instantiation
)
1963 tree tmpl
= NULL_TREE
;
1964 tree targs
= NULL_TREE
;
1966 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1967 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
1971 gcc_assert (TREE_CODE (declarator
) == IDENTIFIER_NODE
);
1976 /* If there is no class context, the explicit instantiation
1977 must be at namespace scope. */
1978 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
1980 /* Find the namespace binding, using the declaration
1982 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
1984 if (!fns
|| !is_overloaded_fn (fns
))
1986 error ("%qD is not a template function", dname
);
1987 fns
= error_mark_node
;
1991 tree fn
= OVL_CURRENT (fns
);
1992 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
1993 CP_DECL_CONTEXT (fn
)))
1994 error ("%qD is not declared in %qD",
1995 decl
, current_namespace
);
1999 declarator
= lookup_template_function (fns
, NULL_TREE
);
2002 if (declarator
== error_mark_node
)
2003 return error_mark_node
;
2005 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2007 if (!explicit_instantiation
)
2008 /* A specialization in class scope. This is invalid,
2009 but the error will already have been flagged by
2010 check_specialization_scope. */
2011 return error_mark_node
;
2014 /* It's not valid to write an explicit instantiation in
2017 class C { template void f(); }
2019 This case is caught by the parser. However, on
2022 template class C { void f(); };
2024 (which is invalid) we can get here. The error will be
2031 else if (ctype
!= NULL_TREE
2032 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) ==
2035 /* Find the list of functions in ctype that have the same
2036 name as the declared function. */
2037 tree name
= TREE_OPERAND (declarator
, 0);
2038 tree fns
= NULL_TREE
;
2041 if (constructor_name_p (name
, ctype
))
2043 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2045 if (is_constructor
? !TYPE_HAS_CONSTRUCTOR (ctype
)
2046 : !CLASSTYPE_DESTRUCTORS (ctype
))
2048 /* From [temp.expl.spec]:
2050 If such an explicit specialization for the member
2051 of a class template names an implicitly-declared
2052 special member function (clause _special_), the
2053 program is ill-formed.
2055 Similar language is found in [temp.explicit]. */
2056 error ("specialization of implicitly-declared special member function");
2057 return error_mark_node
;
2060 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2063 if (!DECL_CONV_FN_P (decl
))
2065 idx
= lookup_fnfields_1 (ctype
, name
);
2067 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (ctype
), idx
);
2071 VEC(tree
,gc
) *methods
;
2074 /* For a type-conversion operator, we cannot do a
2075 name-based lookup. We might be looking for `operator
2076 int' which will be a specialization of `operator T'.
2077 So, we find *all* the conversion operators, and then
2078 select from them. */
2081 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2083 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2084 VEC_iterate (tree
, methods
, idx
, ovl
);
2087 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2088 /* There are no more conversion functions. */
2091 /* Glue all these conversion functions together
2092 with those we already have. */
2093 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2094 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2098 if (fns
== NULL_TREE
)
2100 error ("no member function %qD declared in %qT", name
, ctype
);
2101 return error_mark_node
;
2104 TREE_OPERAND (declarator
, 0) = fns
;
2107 /* Figure out what exactly is being specialized at this point.
2108 Note that for an explicit instantiation, even one for a
2109 member function, we cannot tell apriori whether the
2110 instantiation is for a member template, or just a member
2111 function of a template class. Even if a member template is
2112 being instantiated, the member template arguments may be
2113 elided if they can be deduced from the rest of the
2115 tmpl
= determine_specialization (declarator
, decl
,
2117 member_specialization
,
2121 if (!tmpl
|| tmpl
== error_mark_node
)
2122 /* We couldn't figure out what this declaration was
2124 return error_mark_node
;
2127 tree gen_tmpl
= most_general_template (tmpl
);
2129 if (explicit_instantiation
)
2131 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2132 is done by do_decl_instantiation later. */
2134 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2135 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2137 if (arg_depth
> parm_depth
)
2139 /* If TMPL is not the most general template (for
2140 example, if TMPL is a friend template that is
2141 injected into namespace scope), then there will
2142 be too many levels of TARGS. Remove some of them
2147 new_targs
= make_tree_vec (parm_depth
);
2148 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2149 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2150 = TREE_VEC_ELT (targs
, i
);
2154 return instantiate_template (tmpl
, targs
, tf_error
);
2157 /* If we thought that the DECL was a member function, but it
2158 turns out to be specializing a static member function,
2159 make DECL a static member function as well. */
2160 if (DECL_STATIC_FUNCTION_P (tmpl
)
2161 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2162 revert_static_member_fn (decl
);
2164 /* If this is a specialization of a member template of a
2165 template class, we want to return the TEMPLATE_DECL, not
2166 the specialization of it. */
2167 if (tsk
== tsk_template
)
2169 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2170 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
)) = NULL_TREE
;
2173 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2174 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl
))
2175 = DECL_SOURCE_LOCATION (decl
);
2176 /* We want to use the argument list specified in the
2177 definition, not in the original declaration. */
2178 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl
))
2179 = DECL_ARGUMENTS (decl
);
2184 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2185 DECL_TEMPLATE_INFO (decl
) = tree_cons (tmpl
, targs
, NULL_TREE
);
2187 /* Inherit default function arguments from the template
2188 DECL is specializing. */
2189 copy_default_args_to_explicit_spec (decl
);
2191 /* This specialization has the same protection as the
2192 template it specializes. */
2193 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2194 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2196 /* 7.1.1-1 [dcl.stc]
2198 A storage-class-specifier shall not be specified in an
2199 explicit specialization...
2201 The parser rejects these, so unless action is taken here,
2202 explicit function specializations will always appear with
2205 The action recommended by the C++ CWG in response to C++
2206 defect report 605 is to make the storage class and linkage
2207 of the explicit specialization match the templated function:
2209 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2211 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2213 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2214 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2216 /* This specialization has the same linkage and visibility as
2217 the function template it specializes. */
2218 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2219 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2220 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2222 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2223 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2227 /* If DECL is a friend declaration, declared using an
2228 unqualified name, the namespace associated with DECL may
2229 have been set incorrectly. For example, in:
2231 template <typename T> void f(T);
2233 struct S { friend void f<int>(int); }
2236 we will have set the DECL_CONTEXT for the friend
2237 declaration to N, rather than to the global namespace. */
2238 if (DECL_NAMESPACE_SCOPE_P (decl
))
2239 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2241 if (is_friend
&& !have_def
)
2242 /* This is not really a declaration of a specialization.
2243 It's just the name of an instantiation. But, it's not
2244 a request for an instantiation, either. */
2245 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2246 else if (DECL_CONSTRUCTOR_P (decl
) || DECL_DESTRUCTOR_P (decl
))
2247 /* This is indeed a specialization. In case of constructors
2248 and destructors, we need in-charge and not-in-charge
2249 versions in V3 ABI. */
2250 clone_function_decl (decl
, /*update_method_vec_p=*/0);
2252 /* Register this specialization so that we can find it
2254 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
);
2261 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2262 parameters. These are represented in the same format used for
2263 DECL_TEMPLATE_PARMS. */
2266 comp_template_parms (tree parms1
, tree parms2
)
2271 if (parms1
== parms2
)
2274 for (p1
= parms1
, p2
= parms2
;
2275 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2276 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2278 tree t1
= TREE_VALUE (p1
);
2279 tree t2
= TREE_VALUE (p2
);
2282 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2283 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2285 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2288 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2290 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2291 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2293 /* If either of the template parameters are invalid, assume
2294 they match for the sake of error recovery. */
2295 if (parm1
== error_mark_node
|| parm2
== error_mark_node
)
2298 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2301 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2302 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2303 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2305 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2310 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2311 /* One set of parameters has more parameters lists than the
2318 /* Determine whether PARM is a parameter pack. */
2320 template_parameter_pack_p (tree parm
)
2322 /* Determine if we have a non-type template parameter pack. */
2323 if (TREE_CODE (parm
) == PARM_DECL
)
2324 return (DECL_TEMPLATE_PARM_P (parm
)
2325 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2327 /* If this is a list of template parameters, we could get a
2328 TYPE_DECL or a TEMPLATE_DECL. */
2329 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2330 parm
= TREE_TYPE (parm
);
2332 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2333 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2334 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2337 /* Determine whether ARGS describes a variadic template args list,
2338 i.e., one that is terminated by a template argument pack. */
2340 template_args_variadic_p (tree args
)
2345 if (args
== NULL_TREE
)
2348 args
= INNERMOST_TEMPLATE_ARGS (args
);
2349 nargs
= TREE_VEC_LENGTH (args
);
2354 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2356 return ARGUMENT_PACK_P (last_parm
);
2359 /* Generate a new name for the parameter pack name NAME (an
2360 IDENTIFIER_NODE) that incorporates its */
2362 make_ith_pack_parameter_name (tree name
, int i
)
2364 /* Munge the name to include the parameter index. */
2368 sprintf(numbuf
, "%i", i
);
2369 newname
= (char*)alloca (IDENTIFIER_LENGTH (name
) + strlen(numbuf
) + 2);
2370 sprintf(newname
, "%s#%i", IDENTIFIER_POINTER (name
), i
);
2371 return get_identifier (newname
);
2374 /* Structure used to track the progress of find_parameter_pack_r. */
2375 struct find_parameter_pack_data
2377 tree
* parameter_packs
;
2378 struct pointer_set_t
*visited
;
2381 /* Identifiers all of the argument packs that occur in a template
2382 argument and appends them to the TREE_LIST inside DATA, which is a
2383 find_parameter_pack_Data structure. This is a subroutine of
2384 make_pack_expansion and uses_parameter_packs. */
2386 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
2389 struct find_parameter_pack_data
* ppd
=
2390 (struct find_parameter_pack_data
*)data
;
2394 tree context
= TYPE_CONTEXT (t
);
2395 walk_tree (&context
, &find_parameter_packs_r
, ppd
, ppd
->visited
);
2398 /* This switch statement will return immediately if we don't find a
2400 switch (TREE_CODE (t
))
2402 case TEMPLATE_PARM_INDEX
:
2403 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
2407 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2408 /* Check the template arguments. */
2409 walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
2412 /* Dig out the underlying TEMPLATE_TEMPLATE_PARM. */
2413 t
= TYPE_TI_TEMPLATE (t
);
2414 if (DECL_P (t
) && TREE_TYPE (t
))
2420 case TEMPLATE_TYPE_PARM
:
2421 case TEMPLATE_TEMPLATE_PARM
:
2422 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
2427 if (FUNCTION_PARAMETER_PACK_P (t
))
2429 /* We don't want to walk into the type of a PARM_DECL,
2430 because we don't want to see the type parameter pack.*/
2437 if (TYPE_PTRMEMFUNC_P (t
))
2443 if (TYPE_TEMPLATE_INFO (t
))
2445 tree args
= TREE_VALUE (TYPE_TEMPLATE_INFO (t
));
2446 walk_tree (&args
, &find_parameter_packs_r
, ppd
, ppd
->visited
);
2453 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
2454 && TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
2460 case TYPE_PACK_EXPANSION
:
2461 case EXPR_PACK_EXPANSION
:
2466 walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
2475 /* Add this parameter pack to the list. */
2476 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
2481 /* Determines if the expression or type T uses any parameter packs. */
2483 uses_parameter_packs (tree t
)
2485 tree parameter_packs
= NULL_TREE
;
2486 struct find_parameter_pack_data ppd
;
2487 ppd
.parameter_packs
= ¶meter_packs
;
2488 ppd
.visited
= pointer_set_create ();
2489 walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
2490 pointer_set_destroy (ppd
.visited
);
2491 return parameter_packs
!= NULL_TREE
;
2494 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2495 representation a base-class initializer into a parameter pack
2496 expansion. If all goes well, the resulting node will be an
2497 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2500 make_pack_expansion (tree arg
)
2503 tree parameter_packs
= NULL_TREE
;
2504 bool for_types
= false;
2505 struct find_parameter_pack_data ppd
;
2507 if (!arg
|| arg
== error_mark_node
)
2510 if (TREE_CODE (arg
) == TREE_LIST
)
2512 /* The only time we will see a TREE_LIST here is for a base
2513 class initializer. In this case, the TREE_PURPOSE will be a
2514 _TYPE node (representing the base class expansion we're
2515 initializing) and the TREE_VALUE will be a TREE_LIST
2516 containing the initialization arguments.
2518 The resulting expansion looks somewhat different from most
2519 expansions. Rather than returning just one _EXPANSION, we
2520 return a TREE_LIST whose TREE_PURPOSE is a
2521 TYPE_PACK_EXPANSION containing the bases that will be
2522 initialized. The TREE_VALUE will be identical to the
2523 original TREE_VALUE, which is a list of arguments that will
2524 be passed to each base. We do not introduce any new pack
2525 expansion nodes into the TREE_VALUE (although it is possible
2526 that some already exist), because the TREE_PURPOSE and
2527 TREE_VALUE all need to be expanded together with the same
2528 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2529 resulting TREE_PURPOSE will mention the parameter packs in
2530 both the bases and the arguments to the bases. */
2533 tree parameter_packs
= NULL_TREE
;
2535 /* Determine which parameter packs will be used by the base
2537 ppd
.visited
= pointer_set_create ();
2538 ppd
.parameter_packs
= ¶meter_packs
;
2539 walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
2542 if (parameter_packs
== NULL_TREE
)
2544 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
2545 pointer_set_destroy (ppd
.visited
);
2546 return error_mark_node
;
2549 if (TREE_VALUE (arg
) != void_type_node
)
2551 /* Collect the sets of parameter packs used in each of the
2552 initialization arguments. */
2553 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
2555 /* Determine which parameter packs will be expanded in this
2557 walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
2562 pointer_set_destroy (ppd
.visited
);
2564 /* Create the pack expansion type for the base type. */
2565 purpose
= make_node (TYPE_PACK_EXPANSION
);
2566 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
2567 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
2569 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2570 they will rarely be compared to anything. */
2571 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
2573 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
2576 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
2579 /* Build the PACK_EXPANSION_* node. */
2580 result
= make_node (for_types
? TYPE_PACK_EXPANSION
: EXPR_PACK_EXPANSION
);
2581 SET_PACK_EXPANSION_PATTERN (result
, arg
);
2582 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
2584 /* Propagate type and const-expression information. */
2585 TREE_TYPE (result
) = TREE_TYPE (arg
);
2586 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
2589 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2590 they will rarely be compared to anything. */
2591 SET_TYPE_STRUCTURAL_EQUALITY (result
);
2593 /* Determine which parameter packs will be expanded. */
2594 ppd
.parameter_packs
= ¶meter_packs
;
2595 ppd
.visited
= pointer_set_create ();
2596 walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
2597 pointer_set_destroy (ppd
.visited
);
2599 /* Make sure we found some parameter packs. */
2600 if (parameter_packs
== NULL_TREE
)
2603 error ("expansion pattern %<%T%> contains no argument packs", arg
);
2605 error ("expansion pattern %<%E%> contains no argument packs", arg
);
2606 return error_mark_node
;
2608 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
2613 /* Checks T for any "bare" parameter packs, which have not yet been
2614 expanded, and issues an error if any are found. This operation can
2615 only be done on full expressions or types (e.g., an expression
2616 statement, "if" condition, etc.), because we could have expressions like:
2618 foo(f(g(h(args)))...)
2620 where "args" is a parameter pack. check_for_bare_parameter_packs
2621 should not be called for the subexpressions args, h(args),
2622 g(h(args)), or f(g(h(args))), because we would produce erroneous
2625 Returns TRUE if there were no bare parameter packs, returns FALSE
2626 (and emits an error) if there were bare parameter packs.*/
2628 check_for_bare_parameter_packs (tree t
)
2630 tree parameter_packs
= NULL_TREE
;
2631 struct find_parameter_pack_data ppd
;
2633 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
2636 if (TREE_CODE (t
) == TYPE_DECL
)
2639 ppd
.parameter_packs
= ¶meter_packs
;
2640 ppd
.visited
= pointer_set_create ();
2641 walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
2642 pointer_set_destroy (ppd
.visited
);
2644 if (parameter_packs
)
2646 error ("parameter packs not expanded with `...':");
2647 while (parameter_packs
)
2649 tree pack
= TREE_VALUE (parameter_packs
);
2650 tree name
= NULL_TREE
;
2652 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
2653 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
2654 name
= TYPE_NAME (pack
);
2655 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
2656 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
2658 name
= DECL_NAME (pack
);
2659 inform (" %qD", name
);
2661 parameter_packs
= TREE_CHAIN (parameter_packs
);
2670 /* Expand any parameter packs that occur in the template arguments in
2673 expand_template_argument_pack (tree args
)
2675 tree result_args
= NULL_TREE
;
2676 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
2677 int num_result_args
= -1;
2679 /* First, determine if we need to expand anything, and the number of
2680 slots we'll need. */
2681 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
2683 tree arg
= TREE_VEC_ELT (args
, in_arg
);
2684 if (ARGUMENT_PACK_P (arg
))
2686 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
2687 if (num_result_args
< 0)
2688 num_result_args
= in_arg
+ num_packed
;
2690 num_result_args
+= num_packed
;
2694 if (num_result_args
>= 0)
2699 /* If no expansion is necessary, we're done. */
2700 if (num_result_args
< 0)
2703 /* Expand arguments. */
2704 result_args
= make_tree_vec (num_result_args
);
2705 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
2707 tree arg
= TREE_VEC_ELT (args
, in_arg
);
2708 if (ARGUMENT_PACK_P (arg
))
2710 tree packed
= ARGUMENT_PACK_ARGS (arg
);
2711 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
2712 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
2713 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
2717 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
2725 /* Complain if DECL shadows a template parameter.
2727 [temp.local]: A template-parameter shall not be redeclared within its
2728 scope (including nested scopes). */
2731 check_template_shadow (tree decl
)
2735 /* If we're not in a template, we can't possibly shadow a template
2737 if (!current_template_parms
)
2740 /* Figure out what we're shadowing. */
2741 if (TREE_CODE (decl
) == OVERLOAD
)
2742 decl
= OVL_CURRENT (decl
);
2743 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
2745 /* If there's no previous binding for this name, we're not shadowing
2746 anything, let alone a template parameter. */
2750 /* If we're not shadowing a template parameter, we're done. Note
2751 that OLDDECL might be an OVERLOAD (or perhaps even an
2752 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2754 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
2757 /* We check for decl != olddecl to avoid bogus errors for using a
2758 name inside a class. We check TPFI to avoid duplicate errors for
2759 inline member templates. */
2761 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
2764 error ("declaration of %q+#D", decl
);
2765 error (" shadows template parm %q+#D", olddecl
);
2768 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2769 ORIG_LEVEL, DECL, and TYPE. */
2772 build_template_parm_index (int index
,
2778 tree t
= make_node (TEMPLATE_PARM_INDEX
);
2779 TEMPLATE_PARM_IDX (t
) = index
;
2780 TEMPLATE_PARM_LEVEL (t
) = level
;
2781 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
2782 TEMPLATE_PARM_DECL (t
) = decl
;
2783 TREE_TYPE (t
) = type
;
2784 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
2785 TREE_INVARIANT (t
) = TREE_INVARIANT (decl
);
2786 TREE_READONLY (t
) = TREE_READONLY (decl
);
2791 /* Find the canonical type parameter for the given template type
2792 parameter. Returns the canonical type parameter, which may be TYPE
2793 if no such parameter existed. */
2795 canonical_type_parameter (tree type
)
2798 int idx
= TEMPLATE_TYPE_IDX (type
);
2799 if (!canonical_template_parms
)
2800 canonical_template_parms
= VEC_alloc (tree
, gc
, idx
+1);
2802 while (VEC_length (tree
, canonical_template_parms
) <= (unsigned)idx
)
2803 VEC_safe_push (tree
, gc
, canonical_template_parms
, NULL_TREE
);
2805 list
= VEC_index (tree
, canonical_template_parms
, idx
);
2806 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
2807 list
= TREE_CHAIN (list
);
2810 return TREE_VALUE (list
);
2813 VEC_replace(tree
, canonical_template_parms
, idx
,
2814 tree_cons (NULL_TREE
, type
,
2815 VEC_index (tree
, canonical_template_parms
, idx
)));
2820 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2821 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2822 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2823 new one is created. */
2826 reduce_template_parm_level (tree index
, tree type
, int levels
)
2828 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
2829 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
2830 != TEMPLATE_PARM_LEVEL (index
) - levels
))
2832 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
2835 decl
= build_decl (TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
2836 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
2837 TREE_INVARIANT (decl
) = TREE_INVARIANT (orig_decl
);
2838 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
2839 DECL_ARTIFICIAL (decl
) = 1;
2840 SET_DECL_TEMPLATE_PARM_P (decl
);
2842 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
2843 TEMPLATE_PARM_LEVEL (index
) - levels
,
2844 TEMPLATE_PARM_ORIG_LEVEL (index
),
2846 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
2847 TEMPLATE_PARM_PARAMETER_PACK (t
)
2848 = TEMPLATE_PARM_PARAMETER_PACK (index
);
2850 /* Template template parameters need this. */
2851 if (TREE_CODE (decl
) != CONST_DECL
)
2852 DECL_TEMPLATE_PARMS (decl
)
2853 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
));
2856 return TEMPLATE_PARM_DESCENDANTS (index
);
2859 /* Process information from new template parameter PARM and append it to the
2860 LIST being built. This new parameter is a non-type parameter iff
2861 IS_NON_TYPE is true. This new parameter is a parameter
2862 pack iff IS_PARAMETER_PACK is true. */
2865 process_template_parm (tree list
, tree parm
, bool is_non_type
,
2866 bool is_parameter_pack
)
2873 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
2874 defval
= TREE_PURPOSE (parm
);
2878 tree p
= tree_last (list
);
2880 if (p
&& TREE_VALUE (p
) != error_mark_node
)
2883 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
2884 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
2886 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
2896 parm
= TREE_VALUE (parm
);
2898 SET_DECL_TEMPLATE_PARM_P (parm
);
2900 if (TREE_TYPE (parm
) == error_mark_node
)
2902 err_parm_list
= build_tree_list (defval
, parm
);
2903 TREE_VALUE (err_parm_list
) = error_mark_node
;
2904 return chainon (list
, err_parm_list
);
2910 The top-level cv-qualifiers on the template-parameter are
2911 ignored when determining its type. */
2912 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
2913 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
2915 err_parm_list
= build_tree_list (defval
, parm
);
2916 TREE_VALUE (err_parm_list
) = error_mark_node
;
2917 return chainon (list
, err_parm_list
);
2920 if (uses_parameter_packs (TREE_TYPE (parm
)) && !is_parameter_pack
)
2922 /* This template parameter is not a parameter pack, but it
2923 should be. Complain about "bare" parameter packs. */
2924 check_for_bare_parameter_packs (TREE_TYPE (parm
));
2926 /* Recover by calling this a parameter pack. */
2927 is_parameter_pack
= true;
2931 /* A template parameter is not modifiable. */
2932 TREE_CONSTANT (parm
) = 1;
2933 TREE_INVARIANT (parm
) = 1;
2934 TREE_READONLY (parm
) = 1;
2935 decl
= build_decl (CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
2936 TREE_CONSTANT (decl
) = 1;
2937 TREE_INVARIANT (decl
) = 1;
2938 TREE_READONLY (decl
) = 1;
2939 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
2940 = build_template_parm_index (idx
, processing_template_decl
,
2941 processing_template_decl
,
2942 decl
, TREE_TYPE (parm
));
2944 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
2945 = is_parameter_pack
;
2950 parm
= TREE_VALUE (TREE_VALUE (parm
));
2952 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
2954 t
= make_aggr_type (TEMPLATE_TEMPLATE_PARM
);
2955 /* This is for distinguishing between real templates and template
2956 template parameters */
2957 TREE_TYPE (parm
) = t
;
2958 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
2963 t
= make_aggr_type (TEMPLATE_TYPE_PARM
);
2964 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2965 decl
= build_decl (TYPE_DECL
, parm
, t
);
2968 TYPE_NAME (t
) = decl
;
2969 TYPE_STUB_DECL (t
) = decl
;
2971 TEMPLATE_TYPE_PARM_INDEX (t
)
2972 = build_template_parm_index (idx
, processing_template_decl
,
2973 processing_template_decl
,
2974 decl
, TREE_TYPE (parm
));
2975 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
2976 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
2978 DECL_ARTIFICIAL (decl
) = 1;
2979 SET_DECL_TEMPLATE_PARM_P (decl
);
2981 parm
= build_tree_list (defval
, parm
);
2982 return chainon (list
, parm
);
2985 /* The end of a template parameter list has been reached. Process the
2986 tree list into a parameter vector, converting each parameter into a more
2987 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2991 end_template_parm_list (tree parms
)
2995 tree saved_parmlist
= make_tree_vec (list_length (parms
));
2997 current_template_parms
2998 = tree_cons (size_int (processing_template_decl
),
2999 saved_parmlist
, current_template_parms
);
3001 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3003 next
= TREE_CHAIN (parm
);
3004 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3005 TREE_CHAIN (parm
) = NULL_TREE
;
3008 --processing_template_parmlist
;
3010 return saved_parmlist
;
3013 /* end_template_decl is called after a template declaration is seen. */
3016 end_template_decl (void)
3018 reset_specialization ();
3020 if (! processing_template_decl
)
3023 /* This matches the pushlevel in begin_template_parm_list. */
3026 --processing_template_decl
;
3027 current_template_parms
= TREE_CHAIN (current_template_parms
);
3030 /* Within the declaration of a template, return all levels of template
3031 parameters that apply. The template parameters are represented as
3032 a TREE_VEC, in the form documented in cp-tree.h for template
3036 current_template_args (void)
3039 tree args
= NULL_TREE
;
3040 int length
= TMPL_PARMS_DEPTH (current_template_parms
);
3043 /* If there is only one level of template parameters, we do not
3044 create a TREE_VEC of TREE_VECs. Instead, we return a single
3045 TREE_VEC containing the arguments. */
3047 args
= make_tree_vec (length
);
3049 for (header
= current_template_parms
; header
; header
= TREE_CHAIN (header
))
3051 tree a
= copy_node (TREE_VALUE (header
));
3054 TREE_TYPE (a
) = NULL_TREE
;
3055 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3057 tree t
= TREE_VEC_ELT (a
, i
);
3059 /* T will be a list if we are called from within a
3060 begin/end_template_parm_list pair, but a vector directly
3061 if within a begin/end_member_template_processing pair. */
3062 if (TREE_CODE (t
) == TREE_LIST
)
3066 if (t
!= error_mark_node
)
3068 if (TREE_CODE (t
) == TYPE_DECL
3069 || TREE_CODE (t
) == TEMPLATE_DECL
)
3073 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3075 /* Turn this argument into a TYPE_ARGUMENT_PACK
3076 with a single element, which expands T. */
3077 tree vec
= make_tree_vec (1);
3078 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3080 t
= make_node (TYPE_ARGUMENT_PACK
);
3081 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3086 t
= DECL_INITIAL (t
);
3088 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3090 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3091 with a single element, which expands T. */
3092 tree vec
= make_tree_vec (1);
3093 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3094 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3096 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3097 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3098 TREE_TYPE (t
) = type
;
3102 TREE_VEC_ELT (a
, i
) = t
;
3107 TREE_VEC_ELT (args
, --l
) = a
;
3115 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3116 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3117 a member template. Used by push_template_decl below. */
3120 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
3122 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
3123 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
3124 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
3125 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
3126 if (DECL_LANG_SPECIFIC (decl
))
3128 DECL_STATIC_FUNCTION_P (tmpl
) = DECL_STATIC_FUNCTION_P (decl
);
3129 DECL_CONSTRUCTOR_P (tmpl
) = DECL_CONSTRUCTOR_P (decl
);
3130 DECL_DESTRUCTOR_P (tmpl
) = DECL_DESTRUCTOR_P (decl
);
3131 DECL_NONCONVERTING_P (tmpl
) = DECL_NONCONVERTING_P (decl
);
3132 DECL_ASSIGNMENT_OPERATOR_P (tmpl
) = DECL_ASSIGNMENT_OPERATOR_P (decl
);
3133 if (DECL_OVERLOADED_OPERATOR_P (decl
))
3134 SET_OVERLOADED_OPERATOR_CODE (tmpl
,
3135 DECL_OVERLOADED_OPERATOR_P (decl
));
3141 struct template_parm_data
3143 /* The level of the template parameters we are currently
3147 /* The index of the specialization argument we are currently
3151 /* An array whose size is the number of template parameters. The
3152 elements are nonzero if the parameter has been used in any one
3153 of the arguments processed so far. */
3156 /* An array whose size is the number of template arguments. The
3157 elements are nonzero if the argument makes use of template
3158 parameters of this level. */
3159 int* arg_uses_template_parms
;
3162 /* Subroutine of push_template_decl used to see if each template
3163 parameter in a partial specialization is used in the explicit
3164 argument list. If T is of the LEVEL given in DATA (which is
3165 treated as a template_parm_data*), then DATA->PARMS is marked
3169 mark_template_parm (tree t
, void* data
)
3173 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
3175 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
3177 level
= TEMPLATE_PARM_LEVEL (t
);
3178 idx
= TEMPLATE_PARM_IDX (t
);
3182 level
= TEMPLATE_TYPE_LEVEL (t
);
3183 idx
= TEMPLATE_TYPE_IDX (t
);
3186 if (level
== tpd
->level
)
3188 tpd
->parms
[idx
] = 1;
3189 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
3192 /* Return zero so that for_each_template_parm will continue the
3193 traversal of the tree; we want to mark *every* template parm. */
3197 /* Process the partial specialization DECL. */
3200 process_partial_specialization (tree decl
)
3202 tree type
= TREE_TYPE (decl
);
3203 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
3204 tree specargs
= CLASSTYPE_TI_ARGS (type
);
3205 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
3206 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
3207 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
3208 int nargs
= TREE_VEC_LENGTH (inner_args
);
3209 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
3211 int did_error_intro
= 0;
3212 struct template_parm_data tpd
;
3213 struct template_parm_data tpd2
;
3215 /* We check that each of the template parameters given in the
3216 partial specialization is used in the argument list to the
3217 specialization. For example:
3219 template <class T> struct S;
3220 template <class T> struct S<T*>;
3222 The second declaration is OK because `T*' uses the template
3223 parameter T, whereas
3225 template <class T> struct S<int>;
3227 is no good. Even trickier is:
3238 The S2<T> declaration is actually invalid; it is a
3239 full-specialization. Of course,
3242 struct S2<T (*)(U)>;
3244 or some such would have been OK. */
3245 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
3246 tpd
.parms
= (int *) alloca (sizeof (int) * ntparms
);
3247 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
3249 tpd
.arg_uses_template_parms
= (int *) alloca (sizeof (int) * nargs
);
3250 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
3251 for (i
= 0; i
< nargs
; ++i
)
3253 tpd
.current_arg
= i
;
3254 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
3255 &mark_template_parm
,
3259 for (i
= 0; i
< ntparms
; ++i
)
3260 if (tpd
.parms
[i
] == 0)
3262 /* One of the template parms was not used in the
3264 if (!did_error_intro
)
3266 error ("template parameters not used in partial specialization:");
3267 did_error_intro
= 1;
3270 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
3273 /* [temp.class.spec]
3275 The argument list of the specialization shall not be identical to
3276 the implicit argument list of the primary template. */
3277 if (comp_template_args
3279 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3281 error ("partial specialization %qT does not specialize any template arguments", type
);
3283 /* [temp.class.spec]
3285 A partially specialized non-type argument expression shall not
3286 involve template parameters of the partial specialization except
3287 when the argument expression is a simple identifier.
3289 The type of a template parameter corresponding to a specialized
3290 non-type argument shall not be dependent on a parameter of the
3293 Also, we verify that pack expansions only occur at the
3294 end of the argument list. */
3295 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
3297 for (i
= 0; i
< nargs
; ++i
)
3299 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
3300 tree arg
= TREE_VEC_ELT (inner_args
, i
);
3301 tree packed_args
= NULL_TREE
;
3304 if (ARGUMENT_PACK_P (arg
))
3306 /* Extract the arguments from the argument pack. We'll be
3307 iterating over these in the following loop. */
3308 packed_args
= ARGUMENT_PACK_ARGS (arg
);
3309 len
= TREE_VEC_LENGTH (packed_args
);
3312 for (j
= 0; j
< len
; j
++)
3315 /* Get the Jth argument in the parameter pack. */
3316 arg
= TREE_VEC_ELT (packed_args
, j
);
3318 if (PACK_EXPANSION_P (arg
))
3320 /* Pack expansions must come at the end of the
3322 if ((packed_args
&& j
< len
- 1)
3323 || (!packed_args
&& i
< nargs
- 1))
3325 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
3326 error ("parameter pack argument %qE must be at the end of the template argument list", arg
);
3328 error ("parameter pack argument %qT must be at the end of the template argument list", arg
);
3332 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
3333 /* We only care about the pattern. */
3334 arg
= PACK_EXPANSION_PATTERN (arg
);
3336 if (/* These first two lines are the `non-type' bit. */
3338 && TREE_CODE (arg
) != TEMPLATE_DECL
3339 /* This next line is the `argument expression is not just a
3340 simple identifier' condition and also the `specialized
3341 non-type argument' bit. */
3342 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
)
3344 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
3345 || (packed_args
&& uses_template_parms (arg
)))
3346 error ("template argument %qE involves template parameter(s)",
3350 /* Look at the corresponding template parameter,
3351 marking which template parameters its type depends
3353 tree type
= TREE_TYPE (parm
);
3357 /* We haven't yet initialized TPD2. Do so now. */
3358 tpd2
.arg_uses_template_parms
3359 = (int *) alloca (sizeof (int) * nargs
);
3360 /* The number of parameters here is the number in the
3361 main template, which, as checked in the assertion
3363 tpd2
.parms
= (int *) alloca (sizeof (int) * nargs
);
3365 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
3368 /* Mark the template parameters. But this time, we're
3369 looking for the template parameters of the main
3370 template, not in the specialization. */
3371 tpd2
.current_arg
= i
;
3372 tpd2
.arg_uses_template_parms
[i
] = 0;
3373 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
3374 for_each_template_parm (type
,
3375 &mark_template_parm
,
3379 if (tpd2
.arg_uses_template_parms
[i
])
3381 /* The type depended on some template parameters.
3382 If they are fully specialized in the
3383 specialization, that's OK. */
3385 for (j
= 0; j
< nargs
; ++j
)
3386 if (tpd2
.parms
[j
] != 0
3387 && tpd
.arg_uses_template_parms
[j
])
3389 error ("type %qT of template argument %qE depends "
3390 "on template parameter(s)",
3401 if (retrieve_specialization (maintmpl
, specargs
,
3402 /*class_specializations_p=*/true))
3403 /* We've already got this specialization. */
3406 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
3407 = tree_cons (specargs
, inner_parms
,
3408 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
3409 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
3413 /* Check that a template declaration's use of default arguments is not
3414 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
3415 nonzero if DECL is the thing declared by a primary template.
3416 IS_PARTIAL is nonzero if DECL is a partial specialization.
3419 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3420 declaration (but not a definition); 1 indicates a declaration, 2
3421 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3422 emitted for extraneous default arguments.
3424 Returns TRUE if there were no errors found, FALSE otherwise. */
3427 check_default_tmpl_args (tree decl
, tree parms
, int is_primary
,
3428 int is_partial
, int is_friend_decl
)
3431 int last_level_to_check
;
3433 bool no_errors
= true;
3437 A default template-argument shall not be specified in a
3438 function template declaration or a function template definition, nor
3439 in the template-parameter-list of the definition of a member of a
3442 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
3443 /* You can't have a function template declaration in a local
3444 scope, nor you can you define a member of a class template in a
3448 if (current_class_type
3449 && !TYPE_BEING_DEFINED (current_class_type
)
3450 && DECL_LANG_SPECIFIC (decl
)
3451 /* If this is either a friend defined in the scope of the class
3452 or a member function. */
3453 && (DECL_FUNCTION_MEMBER_P (decl
)
3454 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
3455 : DECL_FRIEND_CONTEXT (decl
)
3456 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
3458 /* And, if it was a member function, it really was defined in
3459 the scope of the class. */
3460 && (!DECL_FUNCTION_MEMBER_P (decl
)
3461 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
3462 /* We already checked these parameters when the template was
3463 declared, so there's no need to do it again now. This function
3464 was defined in class scope, but we're processing it's body now
3465 that the class is complete. */
3468 /* Core issue 226 (C++0x only): the following only applies to class
3470 if ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
)
3474 If a template-parameter has a default template-argument, all
3475 subsequent template-parameters shall have a default
3476 template-argument supplied. */
3477 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
3479 tree inner_parms
= TREE_VALUE (parm_level
);
3480 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
3481 int seen_def_arg_p
= 0;
3484 for (i
= 0; i
< ntparms
; ++i
)
3486 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
3488 if (parm
== error_mark_node
)
3491 if (TREE_PURPOSE (parm
))
3493 else if (seen_def_arg_p
)
3495 error ("no default argument for %qD", TREE_VALUE (parm
));
3496 /* For better subsequent error-recovery, we indicate that
3497 there should have been a default argument. */
3498 TREE_PURPOSE (parm
) = error_mark_node
;
3505 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
3509 /* For an ordinary class template, default template arguments are
3510 allowed at the innermost level, e.g.:
3511 template <class T = int>
3513 but, in a partial specialization, they're not allowed even
3514 there, as we have in [temp.class.spec]:
3516 The template parameter list of a specialization shall not
3517 contain default template argument values.
3519 So, for a partial specialization, or for a function template
3520 (in C++98/C++03), we look at all of them. */
3523 /* But, for a primary class template that is not a partial
3524 specialization we look at all template parameters except the
3526 parms
= TREE_CHAIN (parms
);
3528 /* Figure out what error message to issue. */
3529 if (is_friend_decl
== 2)
3530 msg
= "default template arguments may not be used in function template friend re-declaration";
3531 else if (is_friend_decl
)
3532 msg
= "default template arguments may not be used in function template friend declarations";
3533 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
3534 msg
= "default template arguments may not be used in function templates";
3535 else if (is_partial
)
3536 msg
= "default template arguments may not be used in partial specializations";
3538 msg
= "default argument for template parameter for class enclosing %qD";
3540 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
3541 /* If we're inside a class definition, there's no need to
3542 examine the parameters to the class itself. On the one
3543 hand, they will be checked when the class is defined, and,
3544 on the other, default arguments are valid in things like:
3545 template <class T = double>
3546 struct S { template <class U> void f(U); };
3547 Here the default argument for `S' has no bearing on the
3548 declaration of `f'. */
3549 last_level_to_check
= template_class_depth (current_class_type
) + 1;
3551 /* Check everything. */
3552 last_level_to_check
= 0;
3554 for (parm_level
= parms
;
3555 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
3556 parm_level
= TREE_CHAIN (parm_level
))
3558 tree inner_parms
= TREE_VALUE (parm_level
);
3562 ntparms
= TREE_VEC_LENGTH (inner_parms
);
3563 for (i
= 0; i
< ntparms
; ++i
)
3565 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
3568 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
3573 if (is_friend_decl
== 2)
3580 /* Clear out the default argument so that we are not
3582 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
3586 /* At this point, if we're still interested in issuing messages,
3587 they must apply to classes surrounding the object declared. */
3589 msg
= "default argument for template parameter for class enclosing %qD";
3595 /* Worker for push_template_decl_real, called via
3596 for_each_template_parm. DATA is really an int, indicating the
3597 level of the parameters we are interested in. If T is a template
3598 parameter of that level, return nonzero. */
3601 template_parm_this_level_p (tree t
, void* data
)
3603 int this_level
= *(int *)data
;
3606 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
3607 level
= TEMPLATE_PARM_LEVEL (t
);
3609 level
= TEMPLATE_TYPE_LEVEL (t
);
3610 return level
== this_level
;
3613 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3614 parameters given by current_template_args, or reuses a
3615 previously existing one, if appropriate. Returns the DECL, or an
3616 equivalent one, if it is replaced via a call to duplicate_decls.
3618 If IS_FRIEND is true, DECL is a friend declaration. */
3621 push_template_decl_real (tree decl
, bool is_friend
)
3629 int new_template_p
= 0;
3630 /* True if the template is a member template, in the sense of
3632 bool member_template_p
= false;
3634 if (decl
== error_mark_node
)
3637 /* See if this is a partial specialization. */
3638 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
3639 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
3640 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
3642 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
3646 /* For a friend, we want the context of the friend function, not
3647 the type of which it is a friend. */
3648 ctx
= DECL_CONTEXT (decl
);
3649 else if (CP_DECL_CONTEXT (decl
)
3650 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
3651 /* In the case of a virtual function, we want the class in which
3653 ctx
= CP_DECL_CONTEXT (decl
);
3655 /* Otherwise, if we're currently defining some class, the DECL
3656 is assumed to be a member of the class. */
3657 ctx
= current_scope ();
3659 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
3662 if (!DECL_CONTEXT (decl
))
3663 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
3665 /* See if this is a primary template. */
3666 if (is_friend
&& ctx
)
3667 /* A friend template that specifies a class context, i.e.
3668 template <typename T> friend void A<T>::f();
3672 primary
= template_parm_scope_p ();
3676 if (DECL_CLASS_SCOPE_P (decl
))
3677 member_template_p
= true;
3678 if (TREE_CODE (decl
) == TYPE_DECL
3679 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
3680 error ("template class without a name");
3681 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3683 if (DECL_DESTRUCTOR_P (decl
))
3687 A destructor shall not be a member template. */
3688 error ("destructor %qD declared as member template", decl
);
3689 return error_mark_node
;
3691 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
3692 && (!TYPE_ARG_TYPES (TREE_TYPE (decl
))
3693 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
3694 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
3695 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
3696 == void_list_node
)))
3698 /* [basic.stc.dynamic.allocation]
3700 An allocation function can be a function
3701 template. ... Template allocation functions shall
3702 have two or more parameters. */
3703 error ("invalid template declaration of %qD", decl
);
3704 return error_mark_node
;
3707 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
3708 && CLASS_TYPE_P (TREE_TYPE (decl
)))
3712 error ("template declaration of %q#D", decl
);
3713 return error_mark_node
;
3717 /* Check to see that the rules regarding the use of default
3718 arguments are not being violated. */
3719 check_default_tmpl_args (decl
, current_template_parms
,
3720 primary
, is_partial
, /*is_friend_decl=*/0);
3722 /* Ensure that there are no parameter packs in the type of this
3723 declaration that have not been expanded. */
3724 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3726 /* Check each of the arguments individually to see if there are
3727 any bare parameter packs. */
3728 tree type
= TREE_TYPE (decl
);
3729 tree arg
= DECL_ARGUMENTS (decl
);
3730 tree argtype
= TYPE_ARG_TYPES (type
);
3732 while (arg
&& argtype
)
3734 if (!FUNCTION_PARAMETER_PACK_P (arg
)
3735 && !check_for_bare_parameter_packs (TREE_TYPE (arg
)))
3737 /* This is a PARM_DECL that contains unexpanded parameter
3738 packs. We have already complained about this in the
3739 check_for_bare_parameter_packs call, so just replace
3740 these types with ERROR_MARK_NODE. */
3741 TREE_TYPE (arg
) = error_mark_node
;
3742 TREE_VALUE (argtype
) = error_mark_node
;
3745 arg
= TREE_CHAIN (arg
);
3746 argtype
= TREE_CHAIN (argtype
);
3749 /* Check for bare parameter packs in the return type and the
3750 exception specifiers. */
3751 check_for_bare_parameter_packs (TREE_TYPE (type
));
3752 check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
));
3755 check_for_bare_parameter_packs (TREE_TYPE (decl
));
3758 return process_partial_specialization (decl
);
3760 /* A primary class template can only have one parameter pack, at the
3761 end of the template parameter list. */
3762 if (primary
&& TREE_CODE (decl
) == TYPE_DECL
)
3765 = INNERMOST_TEMPLATE_PARMS (current_template_parms
);
3766 int i
, len
= TREE_VEC_LENGTH (inner_parms
);
3767 for (i
= 0; i
< len
- 1; i
++)
3769 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
3771 if (template_parameter_pack_p (parm
))
3773 if (TREE_CODE (parm
) == PARM_DECL
)
3774 error ("parameter pack %qE must be at the end of the"
3775 " template parameter list", parm
);
3777 error ("parameter pack %qT must be at the end of the"
3778 " template parameter list", TREE_TYPE (parm
));
3783 args
= current_template_args ();
3786 || TREE_CODE (ctx
) == FUNCTION_DECL
3787 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
3788 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
3790 if (DECL_LANG_SPECIFIC (decl
)
3791 && DECL_TEMPLATE_INFO (decl
)
3792 && DECL_TI_TEMPLATE (decl
))
3793 tmpl
= DECL_TI_TEMPLATE (decl
);
3794 /* If DECL is a TYPE_DECL for a class-template, then there won't
3795 be DECL_LANG_SPECIFIC. The information equivalent to
3796 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3797 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
3798 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
3799 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
3801 /* Since a template declaration already existed for this
3802 class-type, we must be redeclaring it here. Make sure
3803 that the redeclaration is valid. */
3804 redeclare_class_template (TREE_TYPE (decl
),
3805 current_template_parms
);
3806 /* We don't need to create a new TEMPLATE_DECL; just use the
3807 one we already had. */
3808 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
3812 tmpl
= build_template_decl (decl
, current_template_parms
,
3816 if (DECL_LANG_SPECIFIC (decl
)
3817 && DECL_TEMPLATE_SPECIALIZATION (decl
))
3819 /* A specialization of a member template of a template
3821 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
3822 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
3823 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
3829 tree a
, t
, current
, parms
;
3832 if (TREE_CODE (decl
) == TYPE_DECL
)
3834 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl
)))
3835 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
3836 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
3837 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
3838 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
3841 error ("%qD does not declare a template type", decl
);
3845 else if (!DECL_LANG_SPECIFIC (decl
) || !DECL_TEMPLATE_INFO (decl
))
3847 error ("template definition of non-template %q#D", decl
);
3851 tmpl
= DECL_TI_TEMPLATE (decl
);
3853 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
3854 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
3855 && DECL_TEMPLATE_SPECIALIZATION (decl
)
3856 && DECL_MEMBER_TEMPLATE_P (tmpl
))
3860 /* The declaration is a specialization of a member
3861 template, declared outside the class. Therefore, the
3862 innermost template arguments will be NULL, so we
3863 replace them with the arguments determined by the
3864 earlier call to check_explicit_specialization. */
3865 args
= DECL_TI_ARGS (decl
);
3868 = build_template_decl (decl
, current_template_parms
,
3870 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
3871 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
3872 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
3873 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
3874 DECL_TEMPLATE_INFO (new_tmpl
)
3875 = tree_cons (tmpl
, args
, NULL_TREE
);
3877 register_specialization (new_tmpl
,
3878 most_general_template (tmpl
),
3884 /* Make sure the template headers we got make sense. */
3886 parms
= DECL_TEMPLATE_PARMS (tmpl
);
3887 i
= TMPL_PARMS_DEPTH (parms
);
3888 if (TMPL_ARGS_DEPTH (args
) != i
)
3890 error ("expected %d levels of template parms for %q#D, got %d",
3891 i
, decl
, TMPL_ARGS_DEPTH (args
));
3894 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
3896 a
= TMPL_ARGS_LEVEL (args
, i
);
3897 t
= INNERMOST_TEMPLATE_PARMS (parms
);
3899 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
3901 if (current
== decl
)
3902 error ("got %d template parameters for %q#D",
3903 TREE_VEC_LENGTH (a
), decl
);
3905 error ("got %d template parameters for %q#T",
3906 TREE_VEC_LENGTH (a
), current
);
3907 error (" but %d required", TREE_VEC_LENGTH (t
));
3908 return error_mark_node
;
3911 /* Perhaps we should also check that the parms are used in the
3912 appropriate qualifying scopes in the declarator? */
3914 if (current
== decl
)
3917 current
= TYPE_CONTEXT (current
);
3921 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
3922 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
3924 /* Push template declarations for global functions and types. Note
3925 that we do not try to push a global template friend declared in a
3926 template class; such a thing may well depend on the template
3927 parameters of the class. */
3928 if (new_template_p
&& !ctx
3929 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
3931 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
3932 if (tmpl
== error_mark_node
)
3933 return error_mark_node
;
3935 /* Hide template friend classes that haven't been declared yet. */
3936 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
3938 DECL_ANTICIPATED (tmpl
) = 1;
3939 DECL_FRIEND_P (tmpl
) = 1;
3945 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
3946 if (DECL_CONV_FN_P (tmpl
))
3948 int depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
3950 /* It is a conversion operator. See if the type converted to
3951 depends on innermost template operands. */
3953 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
3955 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
3959 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3960 back to its most general template. If TMPL is a specialization,
3961 ARGS may only have the innermost set of arguments. Add the missing
3962 argument levels if necessary. */
3963 if (DECL_TEMPLATE_INFO (tmpl
))
3964 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
3966 info
= tree_cons (tmpl
, args
, NULL_TREE
);
3968 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
3969 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
3970 else if (DECL_LANG_SPECIFIC (decl
))
3971 DECL_TEMPLATE_INFO (decl
) = info
;
3973 return DECL_TEMPLATE_RESULT (tmpl
);
3977 push_template_decl (tree decl
)
3979 return push_template_decl_real (decl
, false);
3982 /* Called when a class template TYPE is redeclared with the indicated
3983 template PARMS, e.g.:
3985 template <class T> struct S;
3986 template <class T> struct S {}; */
3989 redeclare_class_template (tree type
, tree parms
)
3995 if (!TYPE_TEMPLATE_INFO (type
))
3997 error ("%qT is not a template type", type
);
4001 tmpl
= TYPE_TI_TEMPLATE (type
);
4002 if (!PRIMARY_TEMPLATE_P (tmpl
))
4003 /* The type is nested in some template class. Nothing to worry
4004 about here; there are no new template parameters for the nested
4010 error ("template specifiers not specified in declaration of %qD",
4015 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4016 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
4018 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
4020 error ("previous declaration %q+D", tmpl
);
4021 error ("used %d template parameter(s) instead of %d",
4022 TREE_VEC_LENGTH (tmpl_parms
),
4023 TREE_VEC_LENGTH (parms
));
4027 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
4034 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
4035 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
4038 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
4039 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4040 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
4041 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
4043 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4045 if (tmpl_parm
!= error_mark_node
4046 && (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
4047 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
4048 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))))
4050 error ("template parameter %q+#D", tmpl_parm
);
4051 error ("redeclared here as %q#D", parm
);
4055 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
4057 /* We have in [temp.param]:
4059 A template-parameter may not be given default arguments
4060 by two different declarations in the same scope. */
4061 error ("redefinition of default argument for %q#D", parm
);
4062 error ("%J original definition appeared here", tmpl_parm
);
4066 if (parm_default
!= NULL_TREE
)
4067 /* Update the previous template parameters (which are the ones
4068 that will really count) with the new default value. */
4069 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
4070 else if (tmpl_default
!= NULL_TREE
)
4071 /* Update the new parameters, too; they'll be used as the
4072 parameters for any members. */
4073 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
4079 /* Simplify EXPR if it is a non-dependent expression. Returns the
4080 (possibly simplified) expression. */
4083 fold_non_dependent_expr (tree expr
)
4085 if (expr
== NULL_TREE
)
4088 /* If we're in a template, but EXPR isn't value dependent, simplify
4089 it. We're supposed to treat:
4091 template <typename T> void f(T[1 + 1]);
4092 template <typename T> void f(T[2]);
4094 as two declarations of the same function, for example. */
4095 if (processing_template_decl
4096 && !type_dependent_expression_p (expr
)
4097 && !value_dependent_expression_p (expr
))
4099 HOST_WIDE_INT saved_processing_template_decl
;
4101 saved_processing_template_decl
= processing_template_decl
;
4102 processing_template_decl
= 0;
4103 expr
= tsubst_copy_and_build (expr
,
4106 /*in_decl=*/NULL_TREE
,
4107 /*function_p=*/false,
4108 /*integral_constant_expression_p=*/true);
4109 processing_template_decl
= saved_processing_template_decl
;
4114 /* EXPR is an expression which is used in a constant-expression context.
4115 For instance, it could be a VAR_DECL with a constant initializer.
4116 Extract the innest constant expression.
4118 This is basically a more powerful version of
4119 integral_constant_value, which can be used also in templates where
4120 initializers can maintain a syntactic rather than semantic form
4121 (even if they are non-dependent, for access-checking purposes). */
4124 fold_decl_constant_value (tree expr
)
4126 tree const_expr
= expr
;
4129 expr
= fold_non_dependent_expr (const_expr
);
4130 const_expr
= integral_constant_value (expr
);
4132 while (expr
!= const_expr
);
4137 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4138 must be a function or a pointer-to-function type, as specified
4139 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4140 and check that the resulting function has external linkage. */
4143 convert_nontype_argument_function (tree type
, tree expr
)
4148 fn
= instantiate_type (type
, fns
, tf_none
);
4149 if (fn
== error_mark_node
)
4150 return error_mark_node
;
4153 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
4154 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
4155 if (TREE_CODE (fn_no_ptr
) == BASELINK
)
4156 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
4158 /* [temp.arg.nontype]/1
4160 A template-argument for a non-type, non-template template-parameter
4163 -- the address of an object or function with external linkage. */
4164 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr
))
4166 error ("%qE is not a valid template argument for type %qT "
4167 "because function %qD has not external linkage",
4168 expr
, type
, fn_no_ptr
);
4175 /* Attempt to convert the non-type template parameter EXPR to the
4176 indicated TYPE. If the conversion is successful, return the
4177 converted value. If the conversion is unsuccessful, return
4178 NULL_TREE if we issued an error message, or error_mark_node if we
4179 did not. We issue error messages for out-and-out bad template
4180 parameters, but not simply because the conversion failed, since we
4181 might be just trying to do argument deduction. Both TYPE and EXPR
4182 must be non-dependent.
4184 The conversion follows the special rules described in
4185 [temp.arg.nontype], and it is much more strict than an implicit
4188 This function is called twice for each template argument (see
4189 lookup_template_class for a more accurate description of this
4190 problem). This means that we need to handle expressions which
4191 are not valid in a C++ source, but can be created from the
4192 first call (for instance, casts to perform conversions). These
4193 hacks can go away after we fix the double coercion problem. */
4196 convert_nontype_argument (tree type
, tree expr
)
4200 /* Detect immediately string literals as invalid non-type argument.
4201 This special-case is not needed for correctness (we would easily
4202 catch this later), but only to provide better diagnostic for this
4203 common user mistake. As suggested by DR 100, we do not mention
4204 linkage issues in the diagnostic as this is not the point. */
4205 if (TREE_CODE (expr
) == STRING_CST
)
4207 error ("%qE is not a valid template argument for type %qT "
4208 "because string literals can never be used in this context",
4213 /* If we are in a template, EXPR may be non-dependent, but still
4214 have a syntactic, rather than semantic, form. For example, EXPR
4215 might be a SCOPE_REF, rather than the VAR_DECL to which the
4216 SCOPE_REF refers. Preserving the qualifying scope is necessary
4217 so that access checking can be performed when the template is
4218 instantiated -- but here we need the resolved form so that we can
4219 convert the argument. */
4220 expr
= fold_non_dependent_expr (expr
);
4221 if (error_operand_p (expr
))
4222 return error_mark_node
;
4223 expr_type
= TREE_TYPE (expr
);
4225 /* HACK: Due to double coercion, we can get a
4226 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4227 which is the tree that we built on the first call (see
4228 below when coercing to reference to object or to reference to
4229 function). We just strip everything and get to the arg.
4230 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4232 if (TREE_CODE (expr
) == NOP_EXPR
)
4234 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
4236 /* ??? Maybe we could use convert_from_reference here, but we
4237 would need to relax its constraints because the NOP_EXPR
4238 could actually change the type to something more cv-qualified,
4239 and this is not folded by convert_from_reference. */
4240 tree addr
= TREE_OPERAND (expr
, 0);
4241 gcc_assert (TREE_CODE (expr_type
) == REFERENCE_TYPE
);
4242 gcc_assert (TREE_CODE (addr
) == ADDR_EXPR
);
4243 gcc_assert (TREE_CODE (TREE_TYPE (addr
)) == POINTER_TYPE
);
4244 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4245 (TREE_TYPE (expr_type
),
4246 TREE_TYPE (TREE_TYPE (addr
))));
4248 expr
= TREE_OPERAND (addr
, 0);
4249 expr_type
= TREE_TYPE (expr
);
4252 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4253 parameter is a pointer to object, through decay and
4254 qualification conversion. Let's strip everything. */
4255 else if (TYPE_PTROBV_P (type
))
4258 gcc_assert (TREE_CODE (expr
) == ADDR_EXPR
);
4259 gcc_assert (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
);
4260 /* Skip the ADDR_EXPR only if it is part of the decay for
4261 an array. Otherwise, it is part of the original argument
4262 in the source code. */
4263 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == ARRAY_TYPE
)
4264 expr
= TREE_OPERAND (expr
, 0);
4265 expr_type
= TREE_TYPE (expr
);
4269 /* [temp.arg.nontype]/5, bullet 1
4271 For a non-type template-parameter of integral or enumeration type,
4272 integral promotions (_conv.prom_) and integral conversions
4273 (_conv.integral_) are applied. */
4274 if (INTEGRAL_TYPE_P (type
))
4276 if (!INTEGRAL_TYPE_P (expr_type
))
4277 return error_mark_node
;
4279 expr
= fold_decl_constant_value (expr
);
4280 /* Notice that there are constant expressions like '4 % 0' which
4281 do not fold into integer constants. */
4282 if (TREE_CODE (expr
) != INTEGER_CST
)
4284 error ("%qE is not a valid template argument for type %qT "
4285 "because it is a non-constant expression", expr
, type
);
4289 /* At this point, an implicit conversion does what we want,
4290 because we already know that the expression is of integral
4292 expr
= ocp_convert (type
, expr
, CONV_IMPLICIT
, LOOKUP_PROTECT
);
4293 if (expr
== error_mark_node
)
4294 return error_mark_node
;
4296 /* Conversion was allowed: fold it to a bare integer constant. */
4299 /* [temp.arg.nontype]/5, bullet 2
4301 For a non-type template-parameter of type pointer to object,
4302 qualification conversions (_conv.qual_) and the array-to-pointer
4303 conversion (_conv.array_) are applied. */
4304 else if (TYPE_PTROBV_P (type
))
4306 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4308 A template-argument for a non-type, non-template template-parameter
4309 shall be one of: [...]
4311 -- the name of a non-type template-parameter;
4312 -- the address of an object or function with external linkage, [...]
4313 expressed as "& id-expression" where the & is optional if the name
4314 refers to a function or array, or if the corresponding
4315 template-parameter is a reference.
4317 Here, we do not care about functions, as they are invalid anyway
4318 for a parameter of type pointer-to-object. */
4320 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
4321 /* Non-type template parameters are OK. */
4323 else if (TREE_CODE (expr
) != ADDR_EXPR
4324 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
4326 if (TREE_CODE (expr
) == VAR_DECL
)
4328 error ("%qD is not a valid template argument "
4329 "because %qD is a variable, not the address of "
4334 /* Other values, like integer constants, might be valid
4335 non-type arguments of some other type. */
4336 return error_mark_node
;
4342 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
4343 ? TREE_OPERAND (expr
, 0) : expr
);
4344 if (TREE_CODE (decl
) != VAR_DECL
)
4346 error ("%qE is not a valid template argument of type %qT "
4347 "because %qE is not a variable",
4351 else if (!DECL_EXTERNAL_LINKAGE_P (decl
))
4353 error ("%qE is not a valid template argument of type %qT "
4354 "because %qD does not have external linkage",
4360 expr
= decay_conversion (expr
);
4361 if (expr
== error_mark_node
)
4362 return error_mark_node
;
4364 expr
= perform_qualification_conversions (type
, expr
);
4365 if (expr
== error_mark_node
)
4366 return error_mark_node
;
4368 /* [temp.arg.nontype]/5, bullet 3
4370 For a non-type template-parameter of type reference to object, no
4371 conversions apply. The type referred to by the reference may be more
4372 cv-qualified than the (otherwise identical) type of the
4373 template-argument. The template-parameter is bound directly to the
4374 template-argument, which must be an lvalue. */
4375 else if (TYPE_REF_OBJ_P (type
))
4377 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
4379 return error_mark_node
;
4381 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
4383 error ("%qE is not a valid template argument for type %qT "
4384 "because of conflicts in cv-qualification", expr
, type
);
4388 if (!real_lvalue_p (expr
))
4390 error ("%qE is not a valid template argument for type %qT "
4391 "because it is not an lvalue", expr
, type
);
4395 /* [temp.arg.nontype]/1
4397 A template-argument for a non-type, non-template template-parameter
4398 shall be one of: [...]
4400 -- the address of an object or function with external linkage. */
4401 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
4403 error ("%qE is not a valid template argument for type %qT "
4404 "because object %qD has not external linkage",
4409 expr
= build_nop (type
, build_address (expr
));
4411 /* [temp.arg.nontype]/5, bullet 4
4413 For a non-type template-parameter of type pointer to function, only
4414 the function-to-pointer conversion (_conv.func_) is applied. If the
4415 template-argument represents a set of overloaded functions (or a
4416 pointer to such), the matching function is selected from the set
4418 else if (TYPE_PTRFN_P (type
))
4420 /* If the argument is a template-id, we might not have enough
4421 context information to decay the pointer. */
4422 if (!type_unknown_p (expr_type
))
4424 expr
= decay_conversion (expr
);
4425 if (expr
== error_mark_node
)
4426 return error_mark_node
;
4429 expr
= convert_nontype_argument_function (type
, expr
);
4430 if (!expr
|| expr
== error_mark_node
)
4433 /* [temp.arg.nontype]/5, bullet 5
4435 For a non-type template-parameter of type reference to function, no
4436 conversions apply. If the template-argument represents a set of
4437 overloaded functions, the matching function is selected from the set
4439 else if (TYPE_REFFN_P (type
))
4441 if (TREE_CODE (expr
) == ADDR_EXPR
)
4443 error ("%qE is not a valid template argument for type %qT "
4444 "because it is a pointer", expr
, type
);
4445 inform ("try using %qE instead", TREE_OPERAND (expr
, 0));
4449 expr
= convert_nontype_argument_function (TREE_TYPE (type
), expr
);
4450 if (!expr
|| expr
== error_mark_node
)
4453 expr
= build_nop (type
, build_address (expr
));
4455 /* [temp.arg.nontype]/5, bullet 6
4457 For a non-type template-parameter of type pointer to member function,
4458 no conversions apply. If the template-argument represents a set of
4459 overloaded member functions, the matching member function is selected
4460 from the set (_over.over_). */
4461 else if (TYPE_PTRMEMFUNC_P (type
))
4463 expr
= instantiate_type (type
, expr
, tf_none
);
4464 if (expr
== error_mark_node
)
4465 return error_mark_node
;
4467 /* There is no way to disable standard conversions in
4468 resolve_address_of_overloaded_function (called by
4469 instantiate_type). It is possible that the call succeeded by
4470 converting &B::I to &D::I (where B is a base of D), so we need
4471 to reject this conversion here.
4473 Actually, even if there was a way to disable standard conversions,
4474 it would still be better to reject them here so that we can
4475 provide a superior diagnostic. */
4476 if (!same_type_p (TREE_TYPE (expr
), type
))
4478 /* Make sure we are just one standard conversion off. */
4479 gcc_assert (can_convert (type
, TREE_TYPE (expr
)));
4480 error ("%qE is not a valid template argument for type %qT "
4481 "because it is of type %qT", expr
, type
,
4483 inform ("standard conversions are not allowed in this context");
4487 /* [temp.arg.nontype]/5, bullet 7
4489 For a non-type template-parameter of type pointer to data member,
4490 qualification conversions (_conv.qual_) are applied. */
4491 else if (TYPE_PTRMEM_P (type
))
4493 expr
= perform_qualification_conversions (type
, expr
);
4494 if (expr
== error_mark_node
)
4497 /* A template non-type parameter must be one of the above. */
4501 /* Sanity check: did we actually convert the argument to the
4503 gcc_assert (same_type_p (type
, TREE_TYPE (expr
)));
4508 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4509 template template parameters. Both PARM_PARMS and ARG_PARMS are
4510 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4513 Consider the example:
4514 template <class T> class A;
4515 template<template <class U> class TT> class B;
4517 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4518 the parameters to A, and OUTER_ARGS contains A. */
4521 coerce_template_template_parms (tree parm_parms
,
4523 tsubst_flags_t complain
,
4527 int nparms
, nargs
, i
;
4530 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
4531 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
4533 nparms
= TREE_VEC_LENGTH (parm_parms
);
4534 nargs
= TREE_VEC_LENGTH (arg_parms
);
4536 if (nargs
!= nparms
)
4539 for (i
= 0; i
< nparms
; ++i
)
4541 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
4542 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
4545 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
4546 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
4548 if (arg
== NULL_TREE
|| arg
== error_mark_node
4549 || parm
== NULL_TREE
|| parm
== error_mark_node
)
4552 if (TREE_CODE (arg
) != TREE_CODE (parm
))
4555 switch (TREE_CODE (parm
))
4558 /* We encounter instantiations of templates like
4559 template <template <template <class> class> class TT>
4562 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
4563 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
4565 if (!coerce_template_template_parms
4566 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
4572 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))
4573 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
)))
4574 /* One is a parameter pack, the other is not. */
4579 /* The tsubst call is used to handle cases such as
4581 template <int> class C {};
4582 template <class T, template <T> class TT> class D {};
4585 i.e. the parameter list of TT depends on earlier parameters. */
4586 if (!dependent_type_p (TREE_TYPE (arg
))
4588 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
4592 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4593 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
)))
4594 /* One is a parameter pack, the other is not. */
4605 /* Convert the indicated template ARG as necessary to match the
4606 indicated template PARM. Returns the converted ARG, or
4607 error_mark_node if the conversion was unsuccessful. Error and
4608 warning messages are issued under control of COMPLAIN. This
4609 conversion is for the Ith parameter in the parameter list. ARGS is
4610 the full set of template arguments deduced so far. */
4613 convert_template_argument (tree parm
,
4616 tsubst_flags_t complain
,
4621 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
4622 tree check_arg
= arg
;
4624 if (TREE_CODE (arg
) == TREE_LIST
4625 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
4627 /* The template argument was the name of some
4628 member function. That's usually
4629 invalid, but static members are OK. In any
4630 case, grab the underlying fields/functions
4631 and issue an error later if required. */
4632 arg
= TREE_VALUE (arg
);
4633 TREE_TYPE (arg
) = unknown_type_node
;
4636 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
4637 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
4638 || requires_tmpl_type
);
4640 /* When determining whether an argument pack expansion is a template,
4641 look at the pattern. */
4642 if (TREE_CODE (check_arg
) == TYPE_PACK_EXPANSION
)
4643 check_arg
= PACK_EXPANSION_PATTERN (check_arg
);
4646 ((TREE_CODE (check_arg
) == TEMPLATE_DECL
4647 && TREE_CODE (DECL_TEMPLATE_RESULT (check_arg
)) == TYPE_DECL
)
4648 || TREE_CODE (check_arg
) == TEMPLATE_TEMPLATE_PARM
4649 || TREE_CODE (check_arg
) == UNBOUND_CLASS_TEMPLATE
);
4652 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4653 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
4654 arg
= TYPE_STUB_DECL (arg
);
4656 is_type
= TYPE_P (arg
) || is_tmpl_type
;
4658 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
4659 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
4661 pedwarn ("to refer to a type member of a template parameter, "
4662 "use %<typename %E%>", arg
);
4664 arg
= make_typename_type (TREE_OPERAND (arg
, 0),
4665 TREE_OPERAND (arg
, 1),
4667 complain
& tf_error
);
4670 if (is_type
!= requires_type
)
4674 if (complain
& tf_error
)
4676 error ("type/value mismatch at argument %d in template "
4677 "parameter list for %qD",
4680 error (" expected a constant of type %qT, got %qT",
4682 (is_tmpl_type
? DECL_NAME (arg
) : arg
));
4683 else if (requires_tmpl_type
)
4684 error (" expected a class template, got %qE", arg
);
4686 error (" expected a type, got %qE", arg
);
4689 return error_mark_node
;
4691 if (is_tmpl_type
^ requires_tmpl_type
)
4693 if (in_decl
&& (complain
& tf_error
))
4695 error ("type/value mismatch at argument %d in template "
4696 "parameter list for %qD",
4699 error (" expected a type, got %qT", DECL_NAME (arg
));
4701 error (" expected a class template, got %qT", arg
);
4703 return error_mark_node
;
4708 if (requires_tmpl_type
)
4710 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
4711 /* The number of argument required is not known yet.
4712 Just accept it for now. */
4713 val
= TREE_TYPE (arg
);
4716 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
4720 /* When determining whether a pack expansion is a template,
4721 look at the pattern. */
4722 if (TREE_CODE (check_arg
) == TYPE_PACK_EXPANSION
)
4723 check_arg
= PACK_EXPANSION_PATTERN (check_arg
);
4725 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (check_arg
);
4727 if (coerce_template_template_parms (parmparm
, argparm
,
4733 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4735 if (val
!= error_mark_node
)
4737 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
4738 val
= TREE_TYPE (val
);
4739 else if (TREE_CODE (val
) == TYPE_PACK_EXPANSION
4740 && DECL_TEMPLATE_TEMPLATE_PARM_P (check_arg
))
4742 val
= TREE_TYPE (check_arg
);
4743 val
= make_pack_expansion (val
);
4749 if (in_decl
&& (complain
& tf_error
))
4751 error ("type/value mismatch at argument %d in "
4752 "template parameter list for %qD",
4754 error (" expected a template of type %qD, got %qD",
4758 val
= error_mark_node
;
4764 /* We only form one instance of each template specialization.
4765 Therefore, if we use a non-canonical variant (i.e., a
4766 typedef), any future messages referring to the type will use
4767 the typedef, which is confusing if those future uses do not
4768 themselves also use the typedef. */
4770 val
= canonical_type_variant (val
);
4774 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
4776 if (invalid_nontype_parm_type_p (t
, complain
))
4777 return error_mark_node
;
4779 if (!uses_template_parms (arg
) && !uses_template_parms (t
))
4780 /* We used to call digest_init here. However, digest_init
4781 will report errors, which we don't want when complain
4782 is zero. More importantly, digest_init will try too
4783 hard to convert things: for example, `0' should not be
4784 converted to pointer type at this point according to
4785 the standard. Accepting this is not merely an
4786 extension, since deciding whether or not these
4787 conversions can occur is part of determining which
4788 function template to call, or whether a given explicit
4789 argument specification is valid. */
4790 val
= convert_nontype_argument (t
, arg
);
4794 if (val
== NULL_TREE
)
4795 val
= error_mark_node
;
4796 else if (val
== error_mark_node
&& (complain
& tf_error
))
4797 error ("could not convert template argument %qE to %qT", arg
, t
);
4803 /* Coerces the remaining template arguments in INNER_ARGS (from
4804 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
4805 Returns the coerced argument pack. PARM_IDX is the position of this
4806 parameter in the template parameter list. ARGS is the original
4807 template argument list. */
4809 coerce_template_parameter_pack (tree parms
,
4817 tsubst_flags_t complain
)
4819 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
4820 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
4823 tree packed_types
= NULL_TREE
;
4825 if (arg_idx
> nargs
)
4828 packed_args
= make_tree_vec (nargs
- arg_idx
);
4830 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
4831 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm
))))
4833 /* When the template parameter is a non-type template
4834 parameter pack whose type uses parameter packs, we need
4835 to look at each of the template arguments
4836 separately. Build a vector of the types for these
4837 non-type template parameters in PACKED_TYPES. */
4839 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm
)));
4840 packed_types
= tsubst_pack_expansion (expansion
, args
,
4843 if (packed_types
== error_mark_node
)
4844 return error_mark_node
;
4846 /* Check that we have the right number of arguments. */
4848 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
))
4849 && nargs
- arg_idx
!= TREE_VEC_LENGTH (packed_types
))
4852 = TREE_VEC_LENGTH (parms
) - 1 + TREE_VEC_LENGTH (packed_types
);
4853 error ("wrong number of template arguments (%d, should be %d)",
4854 nargs
, needed_parms
);
4855 return error_mark_node
;
4858 /* If we aren't able to check the actual arguments now
4859 (because they haven't been expanded yet), we can at least
4860 verify that all of the types used for the non-type
4861 template parameter pack are, in fact, valid for non-type
4862 template parameters. */
4864 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
4866 int j
, len
= TREE_VEC_LENGTH (packed_types
);
4867 for (j
= 0; j
< len
; ++j
)
4869 tree t
= TREE_VEC_ELT (packed_types
, j
);
4870 if (invalid_nontype_parm_type_p (t
, complain
))
4871 return error_mark_node
;
4876 /* Convert the remaining arguments, which will be a part of the
4877 parameter pack "parm". */
4878 for (; arg_idx
< nargs
; ++arg_idx
)
4880 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
4881 tree actual_parm
= TREE_VALUE (parm
);
4883 if (packed_types
&& !PACK_EXPANSION_P (arg
))
4885 /* When we have a vector of types (corresponding to the
4886 non-type template parameter pack that uses parameter
4887 packs in its type, as mention above), and the
4888 argument is not an expansion (which expands to a
4889 currently unknown number of arguments), clone the
4890 parm and give it the next type in PACKED_TYPES. */
4891 actual_parm
= copy_node (actual_parm
);
4892 TREE_TYPE (actual_parm
) =
4893 TREE_VEC_ELT (packed_types
, arg_idx
- parm_idx
);
4896 arg
= convert_template_argument (actual_parm
,
4897 arg
, new_args
, complain
, parm_idx
,
4899 if (arg
== error_mark_node
)
4901 TREE_VEC_ELT (packed_args
, arg_idx
- parm_idx
) = arg
;
4904 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
4905 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
4906 argument_pack
= make_node (TYPE_ARGUMENT_PACK
);
4909 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
4910 TREE_TYPE (argument_pack
) = TREE_TYPE (TREE_VALUE (parm
));
4911 TREE_CONSTANT (argument_pack
) = 1;
4914 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
4915 return argument_pack
;
4918 /* Convert all template arguments to their appropriate types, and
4919 return a vector containing the innermost resulting template
4920 arguments. If any error occurs, return error_mark_node. Error and
4921 warning messages are issued under control of COMPLAIN.
4923 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
4924 for arguments not specified in ARGS. Otherwise, if
4925 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
4926 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
4927 USE_DEFAULT_ARGS is false, then all arguments must be specified in
4931 coerce_template_parms (tree parms
,
4934 tsubst_flags_t complain
,
4935 bool require_all_args
,
4936 bool use_default_args
)
4938 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
4941 tree new_inner_args
;
4942 bool saved_skip_evaluation
;
4944 /* When used as a boolean value, indicates whether this is a
4945 variadic template parameter list. Since it's an int, we can also
4946 subtract it from nparms to get the number of non-variadic
4951 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args
));
4953 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
4954 nparms
= TREE_VEC_LENGTH (parms
);
4956 /* Determine if there are any parameter packs. */
4957 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
4959 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
4960 if (template_parameter_pack_p (tparm
))
4967 if ((nargs
> nparms
- variadic_p
&& !variadic_p
)
4968 || (nargs
< nparms
- variadic_p
4970 && (!use_default_args
4971 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
4972 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
4974 if (complain
& tf_error
)
4976 const char *or_more
= "";
4979 or_more
= " or more";
4983 error ("wrong number of template arguments (%d, should be %d%s)",
4984 nargs
, nparms
, or_more
);
4987 error ("provided for %q+D", in_decl
);
4990 return error_mark_node
;
4993 /* We need to evaluate the template arguments, even though this
4994 template-id may be nested within a "sizeof". */
4995 saved_skip_evaluation
= skip_evaluation
;
4996 skip_evaluation
= false;
4997 new_inner_args
= make_tree_vec (nparms
);
4998 new_args
= add_outermost_template_args (args
, new_inner_args
);
4999 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
5004 /* Get the Ith template parameter. */
5005 parm
= TREE_VEC_ELT (parms
, parm_idx
);
5007 if (parm
== error_mark_node
)
5009 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
5013 /* Calculate the next argument. */
5014 if (template_parameter_pack_p (TREE_VALUE (parm
)))
5016 /* All remaining arguments will be placed in the
5017 template parameter pack PARM. */
5018 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
5019 inner_args
, arg_idx
,
5023 /* Store this argument. */
5024 if (arg
== error_mark_node
)
5026 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
5028 /* We are done with all of the arguments. */
5033 else if (arg_idx
< nargs
)
5035 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
5037 if (arg
&& PACK_EXPANSION_P (arg
))
5039 /* If ARG is a pack expansion, but PARM is not a
5040 template parameter pack (if it were, we would have
5041 handled it above), we're trying to expand into a
5042 fixed-length argument list. */
5043 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
5044 error ("cannot expand %<%E%> into a fixed-length "
5045 "argument list", arg
);
5047 error ("cannot expand %<%T%> into a fixed-length "
5048 "argument list", arg
);
5051 else if (require_all_args
)
5052 /* There must be a default arg in this case. */
5053 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
5058 if (arg
== error_mark_node
)
5060 if (complain
& tf_error
)
5061 error ("template argument %d is invalid", arg_idx
+ 1);
5064 /* This only occurs if there was an error in the template
5065 parameter list itself (which we would already have
5066 reported) that we are trying to recover from, e.g., a class
5067 template with a parameter list such as
5068 template<typename..., typename>. */
5069 return error_mark_node
;
5071 arg
= convert_template_argument (TREE_VALUE (parm
),
5072 arg
, new_args
, complain
,
5075 if (arg
== error_mark_node
)
5077 TREE_VEC_ELT (new_inner_args
, arg_idx
) = arg
;
5079 skip_evaluation
= saved_skip_evaluation
;
5082 return error_mark_node
;
5084 return new_inner_args
;
5087 /* Returns 1 if template args OT and NT are equivalent. */
5090 template_args_equal (tree ot
, tree nt
)
5095 if (TREE_CODE (nt
) == TREE_VEC
)
5096 /* For member templates */
5097 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
5098 else if (PACK_EXPANSION_P (ot
))
5099 return PACK_EXPANSION_P (nt
)
5100 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
5101 PACK_EXPANSION_PATTERN (nt
));
5102 else if (TYPE_P (nt
))
5103 return TYPE_P (ot
) && same_type_p (ot
, nt
);
5104 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
5107 return cp_tree_equal (ot
, nt
);
5110 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5111 of template arguments. Returns 0 otherwise. */
5114 comp_template_args (tree oldargs
, tree newargs
)
5118 oldargs
= expand_template_argument_pack (oldargs
);
5119 newargs
= expand_template_argument_pack (newargs
);
5121 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
5124 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
5126 tree nt
= TREE_VEC_ELT (newargs
, i
);
5127 tree ot
= TREE_VEC_ELT (oldargs
, i
);
5129 if (! template_args_equal (ot
, nt
))
5136 add_pending_template (tree d
)
5138 tree ti
= (TYPE_P (d
)
5139 ? CLASSTYPE_TEMPLATE_INFO (d
)
5140 : DECL_TEMPLATE_INFO (d
));
5144 if (TI_PENDING_TEMPLATE_FLAG (ti
))
5147 /* We are called both from instantiate_decl, where we've already had a
5148 tinst_level pushed, and instantiate_template, where we haven't.
5150 level
= !(current_tinst_level
&& TINST_DECL (current_tinst_level
) == d
);
5153 push_tinst_level (d
);
5155 pt
= tree_cons (current_tinst_level
, d
, NULL_TREE
);
5156 if (last_pending_template
)
5157 TREE_CHAIN (last_pending_template
) = pt
;
5159 pending_templates
= pt
;
5161 last_pending_template
= pt
;
5163 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
5170 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5171 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5172 documentation for TEMPLATE_ID_EXPR. */
5175 lookup_template_function (tree fns
, tree arglist
)
5179 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
5180 return error_mark_node
;
5182 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
5183 gcc_assert (fns
&& (is_overloaded_fn (fns
)
5184 || TREE_CODE (fns
) == IDENTIFIER_NODE
));
5186 if (BASELINK_P (fns
))
5188 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
5190 BASELINK_FUNCTIONS (fns
),
5195 type
= TREE_TYPE (fns
);
5196 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
5197 type
= unknown_type_node
;
5199 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
5202 /* Within the scope of a template class S<T>, the name S gets bound
5203 (in build_self_reference) to a TYPE_DECL for the class, not a
5204 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5205 or one of its enclosing classes, and that type is a template,
5206 return the associated TEMPLATE_DECL. Otherwise, the original
5207 DECL is returned. */
5210 maybe_get_template_decl_from_type_decl (tree decl
)
5212 return (decl
!= NULL_TREE
5213 && TREE_CODE (decl
) == TYPE_DECL
5214 && DECL_ARTIFICIAL (decl
)
5215 && CLASS_TYPE_P (TREE_TYPE (decl
))
5216 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
5217 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
5220 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5221 parameters, find the desired type.
5223 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5225 IN_DECL, if non-NULL, is the template declaration we are trying to
5228 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5229 the class we are looking up.
5231 Issue error and warning messages under control of COMPLAIN.
5233 If the template class is really a local class in a template
5234 function, then the FUNCTION_CONTEXT is the function in which it is
5237 ??? Note that this function is currently called *twice* for each
5238 template-id: the first time from the parser, while creating the
5239 incomplete type (finish_template_type), and the second type during the
5240 real instantiation (instantiate_template_class). This is surely something
5241 that we want to avoid. It also causes some problems with argument
5242 coercion (see convert_nontype_argument for more information on this). */
5245 lookup_template_class (tree d1
,
5250 tsubst_flags_t complain
)
5252 tree
template = NULL_TREE
, parmlist
;
5255 timevar_push (TV_NAME_LOOKUP
);
5257 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
5259 tree value
= innermost_non_namespace_value (d1
);
5260 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
5265 push_decl_namespace (context
);
5266 template = lookup_name (d1
);
5267 template = maybe_get_template_decl_from_type_decl (template);
5269 pop_decl_namespace ();
5272 context
= DECL_CONTEXT (template);
5274 else if (TREE_CODE (d1
) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (d1
)))
5276 tree type
= TREE_TYPE (d1
);
5278 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5279 an implicit typename for the second A. Deal with it. */
5280 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5281 type
= TREE_TYPE (type
);
5283 if (CLASSTYPE_TEMPLATE_INFO (type
))
5285 template = CLASSTYPE_TI_TEMPLATE (type
);
5286 d1
= DECL_NAME (template);
5289 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
5290 || (TYPE_P (d1
) && IS_AGGR_TYPE (d1
)))
5292 template = TYPE_TI_TEMPLATE (d1
);
5293 d1
= DECL_NAME (template);
5295 else if (TREE_CODE (d1
) == TEMPLATE_DECL
5296 && TREE_CODE (DECL_TEMPLATE_RESULT (d1
)) == TYPE_DECL
)
5299 d1
= DECL_NAME (template);
5300 context
= DECL_CONTEXT (template);
5303 /* Issue an error message if we didn't find a template. */
5306 if (complain
& tf_error
)
5307 error ("%qT is not a template", d1
);
5308 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5311 if (TREE_CODE (template) != TEMPLATE_DECL
5312 /* Make sure it's a user visible template, if it was named by
5314 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (template)
5315 && !PRIMARY_TEMPLATE_P (template)))
5317 if (complain
& tf_error
)
5319 error ("non-template type %qT used as a template", d1
);
5321 error ("for template declaration %q+D", in_decl
);
5323 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5326 complain
&= ~tf_user
;
5328 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
5330 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5331 template arguments */
5336 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
5338 /* Consider an example where a template template parameter declared as
5340 template <class T, class U = std::allocator<T> > class TT
5342 The template parameter level of T and U are one level larger than
5343 of TT. To proper process the default argument of U, say when an
5344 instantiation `TT<int>' is seen, we need to build the full
5345 arguments containing {int} as the innermost level. Outer levels,
5346 available when not appearing as default template argument, can be
5347 obtained from `current_template_args ()'.
5349 Suppose that TT is later substituted with std::vector. The above
5350 instantiation is `TT<int, std::allocator<T> >' with TT at
5351 level 1, and T at level 2, while the template arguments at level 1
5352 becomes {std::vector} and the inner level 2 is {int}. */
5354 if (current_template_parms
)
5355 arglist
= add_to_template_args (current_template_args (), arglist
);
5357 arglist2
= coerce_template_parms (parmlist
, arglist
, template,
5359 /*require_all_args=*/true,
5360 /*use_default_args=*/true);
5361 if (arglist2
== error_mark_node
5362 || (!uses_template_parms (arglist2
)
5363 && check_instantiated_args (template, arglist2
, complain
)))
5364 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5366 parm
= bind_template_template_parm (TREE_TYPE (template), arglist2
);
5367 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, parm
);
5371 tree template_type
= TREE_TYPE (template);
5374 tree found
= NULL_TREE
;
5377 int is_partial_instantiation
;
5379 gen_tmpl
= most_general_template (template);
5380 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
5381 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
5382 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
5384 if (arg_depth
== 1 && parm_depth
> 1)
5386 /* We've been given an incomplete set of template arguments.
5389 template <class T> struct S1 {
5390 template <class U> struct S2 {};
5391 template <class U> struct S2<U*> {};
5394 we will be called with an ARGLIST of `U*', but the
5395 TEMPLATE will be `template <class T> template
5396 <class U> struct S1<T>::S2'. We must fill in the missing
5399 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
5401 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
5404 /* Now we should have enough arguments. */
5405 gcc_assert (parm_depth
== arg_depth
);
5407 /* From here on, we're only interested in the most general
5409 template = gen_tmpl
;
5411 /* Calculate the BOUND_ARGS. These will be the args that are
5412 actually tsubst'd into the definition to create the
5416 /* We have multiple levels of arguments to coerce, at once. */
5418 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
5420 tree bound_args
= make_tree_vec (parm_depth
);
5422 for (i
= saved_depth
,
5423 t
= DECL_TEMPLATE_PARMS (template);
5424 i
> 0 && t
!= NULL_TREE
;
5425 --i
, t
= TREE_CHAIN (t
))
5427 tree a
= coerce_template_parms (TREE_VALUE (t
),
5430 /*require_all_args=*/true,
5431 /*use_default_args=*/true);
5433 /* Don't process further if one of the levels fails. */
5434 if (a
== error_mark_node
)
5436 /* Restore the ARGLIST to its full size. */
5437 TREE_VEC_LENGTH (arglist
) = saved_depth
;
5438 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5441 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
5443 /* We temporarily reduce the length of the ARGLIST so
5444 that coerce_template_parms will see only the arguments
5445 corresponding to the template parameters it is
5447 TREE_VEC_LENGTH (arglist
)--;
5450 /* Restore the ARGLIST to its full size. */
5451 TREE_VEC_LENGTH (arglist
) = saved_depth
;
5453 arglist
= bound_args
;
5457 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
5458 INNERMOST_TEMPLATE_ARGS (arglist
),
5461 /*require_all_args=*/true,
5462 /*use_default_args=*/true);
5464 if (arglist
== error_mark_node
)
5465 /* We were unable to bind the arguments. */
5466 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5468 /* In the scope of a template class, explicit references to the
5469 template class refer to the type of the template, not any
5470 instantiation of it. For example, in:
5472 template <class T> class C { void f(C<T>); }
5474 the `C<T>' is just the same as `C'. Outside of the
5475 class, however, such a reference is an instantiation. */
5476 if (comp_template_args (TYPE_TI_ARGS (template_type
),
5479 found
= template_type
;
5481 if (!entering_scope
&& PRIMARY_TEMPLATE_P (template))
5485 for (ctx
= current_class_type
;
5486 ctx
&& TREE_CODE (ctx
) != NAMESPACE_DECL
;
5488 ? TYPE_CONTEXT (ctx
)
5489 : DECL_CONTEXT (ctx
)))
5490 if (TYPE_P (ctx
) && same_type_p (ctx
, template_type
))
5493 /* We're not in the scope of the class, so the
5494 TEMPLATE_TYPE is not the type we want after all. */
5500 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5502 /* If we already have this specialization, return it. */
5503 found
= retrieve_specialization (template, arglist
,
5504 /*class_specializations_p=*/false);
5506 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5508 /* This type is a "partial instantiation" if any of the template
5509 arguments still involve template parameters. Note that we set
5510 IS_PARTIAL_INSTANTIATION for partial specializations as
5512 is_partial_instantiation
= uses_template_parms (arglist
);
5514 /* If the deduced arguments are invalid, then the binding
5516 if (!is_partial_instantiation
5517 && check_instantiated_args (template,
5518 INNERMOST_TEMPLATE_ARGS (arglist
),
5520 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5522 if (!is_partial_instantiation
5523 && !PRIMARY_TEMPLATE_P (template)
5524 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL
)
5526 found
= xref_tag_from_type (TREE_TYPE (template),
5527 DECL_NAME (template),
5528 /*tag_scope=*/ts_global
);
5529 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5532 context
= tsubst (DECL_CONTEXT (template), arglist
,
5535 context
= global_namespace
;
5537 /* Create the type. */
5538 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
5540 if (!is_partial_instantiation
)
5542 set_current_access_from_decl (TYPE_NAME (template_type
));
5543 t
= start_enum (TYPE_IDENTIFIER (template_type
));
5546 /* We don't want to call start_enum for this type, since
5547 the values for the enumeration constants may involve
5548 template parameters. And, no one should be interested
5549 in the enumeration constants for such a type. */
5550 t
= make_node (ENUMERAL_TYPE
);
5554 t
= make_aggr_type (TREE_CODE (template_type
));
5555 CLASSTYPE_DECLARED_CLASS (t
)
5556 = CLASSTYPE_DECLARED_CLASS (template_type
);
5557 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
5558 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
5560 /* A local class. Make sure the decl gets registered properly. */
5561 if (context
== current_function_decl
)
5562 pushtag (DECL_NAME (template), t
, /*tag_scope=*/ts_current
);
5564 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
5565 /* This instantiation is another name for the primary
5566 template type. Set the TYPE_CANONICAL field
5568 TYPE_CANONICAL (t
) = template_type
;
5569 else if (any_template_arguments_need_structural_equality_p (arglist
))
5570 /* Some of the template arguments require structural
5571 equality testing, so this template class requires
5572 structural equality testing. */
5573 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5576 /* If we called start_enum or pushtag above, this information
5577 will already be set up. */
5580 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5582 type_decl
= create_implicit_typedef (DECL_NAME (template), t
);
5583 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
5584 TYPE_STUB_DECL (t
) = type_decl
;
5585 DECL_SOURCE_LOCATION (type_decl
)
5586 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
5589 type_decl
= TYPE_NAME (t
);
5591 TREE_PRIVATE (type_decl
)
5592 = TREE_PRIVATE (TYPE_STUB_DECL (template_type
));
5593 TREE_PROTECTED (type_decl
)
5594 = TREE_PROTECTED (TYPE_STUB_DECL (template_type
));
5595 DECL_IN_SYSTEM_HEADER (type_decl
)
5596 = DECL_IN_SYSTEM_HEADER (template);
5597 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
5599 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
5600 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
5603 /* Set up the template information. We have to figure out which
5604 template is the immediate parent if this is a full
5606 if (parm_depth
== 1 || is_partial_instantiation
5607 || !PRIMARY_TEMPLATE_P (template))
5608 /* This case is easy; there are no member templates involved. */
5612 /* This is a full instantiation of a member template. Look
5613 for a partial instantiation of which this is an instance. */
5615 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
5616 found
; found
= TREE_CHAIN (found
))
5619 tree tmpl
= CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found
));
5621 /* We only want partial instantiations, here, not
5622 specializations or full instantiations. */
5623 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found
))
5624 || !uses_template_parms (TREE_VALUE (found
)))
5627 /* Temporarily reduce by one the number of levels in the
5628 ARGLIST and in FOUND so as to avoid comparing the
5629 last set of arguments. */
5630 TREE_VEC_LENGTH (arglist
)--;
5631 TREE_VEC_LENGTH (TREE_PURPOSE (found
)) --;
5633 /* See if the arguments match. If they do, then TMPL is
5634 the partial instantiation we want. */
5635 success
= comp_template_args (TREE_PURPOSE (found
), arglist
);
5637 /* Restore the argument vectors to their full size. */
5638 TREE_VEC_LENGTH (arglist
)++;
5639 TREE_VEC_LENGTH (TREE_PURPOSE (found
))++;
5650 /* There was no partial instantiation. This happens
5651 where C<T> is a member template of A<T> and it's used
5654 template <typename T> struct B { A<T>::C<int> m; };
5657 Create the partial instantiation.
5659 TREE_VEC_LENGTH (arglist
)--;
5660 found
= tsubst (template, arglist
, complain
, NULL_TREE
);
5661 TREE_VEC_LENGTH (arglist
)++;
5665 SET_TYPE_TEMPLATE_INFO (t
, tree_cons (found
, arglist
, NULL_TREE
));
5666 DECL_TEMPLATE_INSTANTIATIONS (template)
5667 = tree_cons (arglist
, t
,
5668 DECL_TEMPLATE_INSTANTIATIONS (template));
5670 if (TREE_CODE (t
) == ENUMERAL_TYPE
5671 && !is_partial_instantiation
)
5672 /* Now that the type has been registered on the instantiations
5673 list, we set up the enumerators. Because the enumeration
5674 constants may involve the enumeration type itself, we make
5675 sure to register the type first, and then create the
5676 constants. That way, doing tsubst_expr for the enumeration
5677 constants won't result in recursive calls here; we'll find
5678 the instantiation and exit above. */
5679 tsubst_enum (template_type
, t
, arglist
);
5681 if (is_partial_instantiation
)
5682 /* If the type makes use of template parameters, the
5683 code that generates debugging information will crash. */
5684 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
5686 /* Possibly limit visibility based on template args. */
5687 TREE_PUBLIC (type_decl
) = 1;
5688 determine_visibility (type_decl
);
5690 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
5692 timevar_pop (TV_NAME_LOOKUP
);
5699 struct pointer_set_t
*visited
;
5702 /* Called from for_each_template_parm via walk_tree. */
5705 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
5708 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
5709 tree_fn_t fn
= pfd
->fn
;
5710 void *data
= pfd
->data
;
5713 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
))
5714 return error_mark_node
;
5716 switch (TREE_CODE (t
))
5719 if (TYPE_PTRMEMFUNC_P (t
))
5725 if (!TYPE_TEMPLATE_INFO (t
))
5727 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t
)),
5728 fn
, data
, pfd
->visited
))
5729 return error_mark_node
;
5733 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
5734 fn
, data
, pfd
->visited
)
5735 || for_each_template_parm (TYPE_MAX_VALUE (t
),
5736 fn
, data
, pfd
->visited
))
5737 return error_mark_node
;
5741 /* Since we're not going to walk subtrees, we have to do this
5743 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
5745 return error_mark_node
;
5749 /* Check the return type. */
5750 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
))
5751 return error_mark_node
;
5753 /* Check the parameter types. Since default arguments are not
5754 instantiated until they are needed, the TYPE_ARG_TYPES may
5755 contain expressions that involve template parameters. But,
5756 no-one should be looking at them yet. And, once they're
5757 instantiated, they don't contain template parameters, so
5758 there's no point in looking at them then, either. */
5762 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
5763 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
5765 return error_mark_node
;
5767 /* Since we've already handled the TYPE_ARG_TYPES, we don't
5768 want walk_tree walking into them itself. */
5774 if (for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
5776 return error_mark_node
;
5781 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
5782 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
5784 return error_mark_node
;
5789 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
5790 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
5792 return error_mark_node
;
5793 if (DECL_CONTEXT (t
)
5794 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
5796 return error_mark_node
;
5799 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5800 /* Record template parameters such as `T' inside `TT<T>'. */
5801 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
))
5802 return error_mark_node
;
5805 case TEMPLATE_TEMPLATE_PARM
:
5806 case TEMPLATE_TYPE_PARM
:
5807 case TEMPLATE_PARM_INDEX
:
5808 if (fn
&& (*fn
)(t
, data
))
5809 return error_mark_node
;
5811 return error_mark_node
;
5815 /* A template template parameter is encountered. */
5816 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
5817 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
))
5818 return error_mark_node
;
5820 /* Already substituted template template parameter */
5826 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
5827 data
, pfd
->visited
))
5828 return error_mark_node
;
5832 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
5833 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
5834 (TREE_TYPE (t
)), fn
, data
,
5836 return error_mark_node
;
5841 /* If there's no type, then this thing must be some expression
5842 involving template parameters. */
5843 if (!fn
&& !TREE_TYPE (t
))
5844 return error_mark_node
;
5849 case REINTERPRET_CAST_EXPR
:
5850 case CONST_CAST_EXPR
:
5851 case STATIC_CAST_EXPR
:
5852 case DYNAMIC_CAST_EXPR
:
5856 case PSEUDO_DTOR_EXPR
:
5858 return error_mark_node
;
5865 /* We didn't find any template parameters we liked. */
5869 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
5870 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
5871 call FN with the parameter and the DATA.
5872 If FN returns nonzero, the iteration is terminated, and
5873 for_each_template_parm returns 1. Otherwise, the iteration
5874 continues. If FN never returns a nonzero value, the value
5875 returned by for_each_template_parm is 0. If FN is NULL, it is
5876 considered to be the function which always returns 1. */
5879 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
5880 struct pointer_set_t
*visited
)
5882 struct pair_fn_data pfd
;
5889 /* Walk the tree. (Conceptually, we would like to walk without
5890 duplicates, but for_each_template_parm_r recursively calls
5891 for_each_template_parm, so we would need to reorganize a fair
5892 bit to use walk_tree_without_duplicates, so we keep our own
5895 pfd
.visited
= visited
;
5897 pfd
.visited
= pointer_set_create ();
5898 result
= walk_tree (&t
,
5899 for_each_template_parm_r
,
5901 pfd
.visited
) != NULL_TREE
;
5906 pointer_set_destroy (pfd
.visited
);
5913 /* Returns true if T depends on any template parameter. */
5916 uses_template_parms (tree t
)
5919 int saved_processing_template_decl
;
5921 saved_processing_template_decl
= processing_template_decl
;
5922 if (!saved_processing_template_decl
)
5923 processing_template_decl
= 1;
5925 dependent_p
= dependent_type_p (t
);
5926 else if (TREE_CODE (t
) == TREE_VEC
)
5927 dependent_p
= any_dependent_template_arguments_p (t
);
5928 else if (TREE_CODE (t
) == TREE_LIST
)
5929 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
5930 || uses_template_parms (TREE_CHAIN (t
)));
5931 else if (TREE_CODE (t
) == TYPE_DECL
)
5932 dependent_p
= dependent_type_p (TREE_TYPE (t
));
5935 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
5936 || TREE_CODE (t
) == OVERLOAD
5937 || TREE_CODE (t
) == BASELINK
5938 || TREE_CODE (t
) == IDENTIFIER_NODE
5939 || TREE_CODE (t
) == TRAIT_EXPR
5940 || CONSTANT_CLASS_P (t
))
5941 dependent_p
= (type_dependent_expression_p (t
)
5942 || value_dependent_expression_p (t
));
5945 gcc_assert (t
== error_mark_node
);
5946 dependent_p
= false;
5949 processing_template_decl
= saved_processing_template_decl
;
5954 /* Returns true if T depends on any template parameter with level LEVEL. */
5957 uses_template_parms_level (tree t
, int level
)
5959 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
);
5962 static int tinst_depth
;
5963 extern int max_tinst_depth
;
5964 #ifdef GATHER_STATISTICS
5967 static int tinst_level_tick
;
5968 static int last_template_error_tick
;
5970 /* We're starting to instantiate D; record the template instantiation context
5971 for diagnostics and to restore it later. */
5974 push_tinst_level (tree d
)
5978 if (tinst_depth
>= max_tinst_depth
)
5980 /* If the instantiation in question still has unbound template parms,
5981 we don't really care if we can't instantiate it, so just return.
5982 This happens with base instantiation for implicit `typename'. */
5983 if (uses_template_parms (d
))
5986 last_template_error_tick
= tinst_level_tick
;
5987 error ("template instantiation depth exceeds maximum of %d (use "
5988 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
5989 max_tinst_depth
, d
);
5991 print_instantiation_context ();
5996 new = make_node (TINST_LEVEL
);
5997 TINST_DECL (new) = d
;
5998 TINST_LOCATION (new) = input_location
;
5999 TINST_IN_SYSTEM_HEADER_P (new) = in_system_header
;
6000 TREE_CHAIN (new) = current_tinst_level
;
6001 current_tinst_level
= new;
6004 #ifdef GATHER_STATISTICS
6005 if (tinst_depth
> depth_reached
)
6006 depth_reached
= tinst_depth
;
6013 /* We're done instantiating this template; return to the instantiation
6017 pop_tinst_level (void)
6019 tree old
= current_tinst_level
;
6021 /* Restore the filename and line number stashed away when we started
6022 this instantiation. */
6023 input_location
= TINST_LOCATION (old
);
6024 in_system_header
= TINST_IN_SYSTEM_HEADER_P (old
);
6025 current_tinst_level
= TREE_CHAIN (old
);
6030 /* We're instantiating a deferred template; restore the template
6031 instantiation context in which the instantiation was requested, which
6032 is one step out from LEVEL. */
6035 reopen_tinst_level (tree level
)
6040 for (t
= level
; t
; t
= TREE_CHAIN (t
))
6043 current_tinst_level
= level
;
6047 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6048 vector of template arguments, as for tsubst.
6050 Returns an appropriate tsubst'd friend declaration. */
6053 tsubst_friend_function (tree decl
, tree args
)
6057 if (TREE_CODE (decl
) == FUNCTION_DECL
6058 && DECL_TEMPLATE_INSTANTIATION (decl
)
6059 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
6060 /* This was a friend declared with an explicit template
6061 argument list, e.g.:
6065 to indicate that f was a template instantiation, not a new
6066 function declaration. Now, we have to figure out what
6067 instantiation of what template. */
6069 tree template_id
, arglist
, fns
;
6072 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
6074 /* Friend functions are looked up in the containing namespace scope.
6075 We must enter that scope, to avoid finding member functions of the
6076 current cless with same name. */
6077 push_nested_namespace (ns
);
6078 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
6079 tf_warning_or_error
, NULL_TREE
,
6080 /*integral_constant_expression_p=*/false);
6081 pop_nested_namespace (ns
);
6082 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
6083 tf_warning_or_error
, NULL_TREE
);
6084 template_id
= lookup_template_function (fns
, arglist
);
6086 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
6087 tmpl
= determine_specialization (template_id
, new_friend
,
6089 /*need_member_template=*/0,
6090 TREE_VEC_LENGTH (args
),
6092 return instantiate_template (tmpl
, new_args
, tf_error
);
6095 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
6097 /* The NEW_FRIEND will look like an instantiation, to the
6098 compiler, but is not an instantiation from the point of view of
6099 the language. For example, we might have had:
6101 template <class T> struct S {
6102 template <class U> friend void f(T, U);
6105 Then, in S<int>, template <class U> void f(int, U) is not an
6106 instantiation of anything. */
6107 if (new_friend
== error_mark_node
)
6108 return error_mark_node
;
6110 DECL_USE_TEMPLATE (new_friend
) = 0;
6111 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
6113 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
6114 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
6115 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
6118 /* The mangled name for the NEW_FRIEND is incorrect. The function
6119 is not a template instantiation and should not be mangled like
6120 one. Therefore, we forget the mangling here; we'll recompute it
6121 later if we need it. */
6122 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
6124 SET_DECL_RTL (new_friend
, NULL_RTX
);
6125 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
6128 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
6131 tree new_friend_template_info
;
6132 tree new_friend_result_template_info
;
6134 int new_friend_is_defn
;
6136 /* We must save some information from NEW_FRIEND before calling
6137 duplicate decls since that function will free NEW_FRIEND if
6139 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
6140 new_friend_is_defn
=
6141 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6142 (template_for_substitution (new_friend
)))
6144 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
6146 /* This declaration is a `primary' template. */
6147 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
6149 new_friend_result_template_info
6150 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
6153 new_friend_result_template_info
= NULL_TREE
;
6155 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6156 if (new_friend_is_defn
)
6157 DECL_INITIAL (new_friend
) = error_mark_node
;
6159 /* Inside pushdecl_namespace_level, we will push into the
6160 current namespace. However, the friend function should go
6161 into the namespace of the template. */
6162 ns
= decl_namespace_context (new_friend
);
6163 push_nested_namespace (ns
);
6164 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
6165 pop_nested_namespace (ns
);
6167 if (old_decl
== error_mark_node
)
6168 return error_mark_node
;
6170 if (old_decl
!= new_friend
)
6172 /* This new friend declaration matched an existing
6173 declaration. For example, given:
6175 template <class T> void f(T);
6176 template <class U> class C {
6177 template <class T> friend void f(T) {}
6180 the friend declaration actually provides the definition
6181 of `f', once C has been instantiated for some type. So,
6182 old_decl will be the out-of-class template declaration,
6183 while new_friend is the in-class definition.
6185 But, if `f' was called before this point, the
6186 instantiation of `f' will have DECL_TI_ARGS corresponding
6187 to `T' but not to `U', references to which might appear
6188 in the definition of `f'. Previously, the most general
6189 template for an instantiation of `f' was the out-of-class
6190 version; now it is the in-class version. Therefore, we
6191 run through all specialization of `f', adding to their
6192 DECL_TI_ARGS appropriately. In particular, they need a
6193 new set of outer arguments, corresponding to the
6194 arguments for this class instantiation.
6196 The same situation can arise with something like this:
6199 template <class T> class C {
6203 when `C<int>' is instantiated. Now, `f(int)' is defined
6206 if (!new_friend_is_defn
)
6207 /* On the other hand, if the in-class declaration does
6208 *not* provide a definition, then we don't want to alter
6209 existing definitions. We can just leave everything
6214 /* Overwrite whatever template info was there before, if
6215 any, with the new template information pertaining to
6217 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
6219 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
6220 reregister_specialization (new_friend
,
6221 most_general_template (old_decl
),
6226 tree new_friend_args
;
6228 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
6229 = new_friend_result_template_info
;
6231 new_friend_args
= TI_ARGS (new_friend_template_info
);
6232 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (old_decl
);
6236 tree spec
= TREE_VALUE (t
);
6239 = add_outermost_template_args (new_friend_args
,
6240 DECL_TI_ARGS (spec
));
6243 /* Now, since specializations are always supposed to
6244 hang off of the most general template, we must move
6246 t
= most_general_template (old_decl
);
6249 DECL_TEMPLATE_SPECIALIZATIONS (t
)
6250 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t
),
6251 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
));
6252 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
) = NULL_TREE
;
6257 /* The information from NEW_FRIEND has been merged into OLD_DECL
6258 by duplicate_decls. */
6259 new_friend
= old_decl
;
6264 tree context
= DECL_CONTEXT (new_friend
);
6268 template <class T> class C {
6269 template <class U> friend void C1<U>::f (); // case 1
6270 friend void C2<T>::f (); // case 2
6272 we only need to make sure CONTEXT is a complete type for
6273 case 2. To distinguish between the two cases, we note that
6274 CONTEXT of case 1 remains dependent type after tsubst while
6275 this isn't true for case 2. */
6276 ++processing_template_decl
;
6277 dependent_p
= dependent_type_p (context
);
6278 --processing_template_decl
;
6281 && !complete_type_or_else (context
, NULL_TREE
))
6282 return error_mark_node
;
6284 if (COMPLETE_TYPE_P (context
))
6286 /* Check to see that the declaration is really present, and,
6287 possibly obtain an improved declaration. */
6288 tree fn
= check_classfn (context
,
6289 new_friend
, NULL_TREE
);
6299 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6300 template arguments, as for tsubst.
6302 Returns an appropriate tsubst'd friend type or error_mark_node on
6306 tsubst_friend_class (tree friend_tmpl
, tree args
)
6312 context
= DECL_CONTEXT (friend_tmpl
);
6316 if (TREE_CODE (context
) == NAMESPACE_DECL
)
6317 push_nested_namespace (context
);
6319 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
6322 /* Look for a class template declaration. We look for hidden names
6323 because two friend declarations of the same template are the
6324 same. For example, in:
6327 template <typename> friend class F;
6329 template <typename> struct B {
6330 template <typename> friend class F;
6333 both F templates are the same. */
6334 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
6335 /*block_p=*/true, 0,
6336 LOOKUP_COMPLAIN
| LOOKUP_HIDDEN
);
6338 /* But, if we don't find one, it might be because we're in a
6339 situation like this:
6347 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6348 for `S<int>', not the TEMPLATE_DECL. */
6349 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
6351 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
6352 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
6355 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
6357 /* The friend template has already been declared. Just
6358 check to see that the declarations match, and install any new
6359 default parameters. We must tsubst the default parameters,
6360 of course. We only need the innermost template parameters
6361 because that is all that redeclare_class_template will look
6363 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
6364 > TMPL_ARGS_DEPTH (args
))
6367 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
6368 args
, tf_warning_or_error
);
6369 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
6372 friend_type
= TREE_TYPE (tmpl
);
6376 /* The friend template has not already been declared. In this
6377 case, the instantiation of the template class will cause the
6378 injection of this template into the global scope. */
6379 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
6380 if (tmpl
== error_mark_node
)
6381 return error_mark_node
;
6383 /* The new TMPL is not an instantiation of anything, so we
6384 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6385 the new type because that is supposed to be the corresponding
6386 template decl, i.e., TMPL. */
6387 DECL_USE_TEMPLATE (tmpl
) = 0;
6388 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
6389 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
6390 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
6391 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
6393 /* Inject this template into the global scope. */
6394 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
6399 if (TREE_CODE (context
) == NAMESPACE_DECL
)
6400 pop_nested_namespace (context
);
6402 pop_nested_class ();
6408 /* Returns zero if TYPE cannot be completed later due to circularity.
6409 Otherwise returns one. */
6412 can_complete_type_without_circularity (tree type
)
6414 if (type
== NULL_TREE
|| type
== error_mark_node
)
6416 else if (COMPLETE_TYPE_P (type
))
6418 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
6419 return can_complete_type_without_circularity (TREE_TYPE (type
));
6420 else if (CLASS_TYPE_P (type
)
6421 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
6428 instantiate_class_template (tree type
)
6430 tree
template, args
, pattern
, t
, member
;
6435 if (type
== error_mark_node
)
6436 return error_mark_node
;
6438 if (TYPE_BEING_DEFINED (type
)
6439 || COMPLETE_TYPE_P (type
)
6440 || dependent_type_p (type
))
6443 /* Figure out which template is being instantiated. */
6444 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
6445 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL
);
6447 /* Determine what specialization of the original template to
6449 t
= most_specialized_class (type
, template);
6450 if (t
== error_mark_node
)
6452 TYPE_BEING_DEFINED (type
) = 1;
6453 return error_mark_node
;
6457 /* This TYPE is actually an instantiation of a partial
6458 specialization. We replace the innermost set of ARGS with
6459 the arguments appropriate for substitution. For example,
6462 template <class T> struct S {};
6463 template <class T> struct S<T*> {};
6465 and supposing that we are instantiating S<int*>, ARGS will
6466 presently be {int*} -- but we need {int}. */
6467 pattern
= TREE_TYPE (t
);
6468 args
= TREE_PURPOSE (t
);
6472 pattern
= TREE_TYPE (template);
6473 args
= CLASSTYPE_TI_ARGS (type
);
6476 /* If the template we're instantiating is incomplete, then clearly
6477 there's nothing we can do. */
6478 if (!COMPLETE_TYPE_P (pattern
))
6481 /* If we've recursively instantiated too many templates, stop. */
6482 if (! push_tinst_level (type
))
6485 /* Now we're really doing the instantiation. Mark the type as in
6486 the process of being defined. */
6487 TYPE_BEING_DEFINED (type
) = 1;
6489 /* We may be in the middle of deferred access check. Disable
6491 push_deferring_access_checks (dk_no_deferred
);
6493 push_to_top_level ();
6495 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
6497 /* Set the input location to the template definition. This is needed
6498 if tsubsting causes an error. */
6499 typedecl
= TYPE_MAIN_DECL (type
);
6500 input_location
= DECL_SOURCE_LOCATION (typedecl
);
6501 in_system_header
= DECL_IN_SYSTEM_HEADER (typedecl
);
6503 TYPE_HAS_CONSTRUCTOR (type
) = TYPE_HAS_CONSTRUCTOR (pattern
);
6504 TYPE_HAS_NEW_OPERATOR (type
) = TYPE_HAS_NEW_OPERATOR (pattern
);
6505 TYPE_HAS_ARRAY_NEW_OPERATOR (type
) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern
);
6506 TYPE_GETS_DELETE (type
) = TYPE_GETS_DELETE (pattern
);
6507 TYPE_HAS_ASSIGN_REF (type
) = TYPE_HAS_ASSIGN_REF (pattern
);
6508 TYPE_HAS_CONST_ASSIGN_REF (type
) = TYPE_HAS_CONST_ASSIGN_REF (pattern
);
6509 TYPE_HAS_INIT_REF (type
) = TYPE_HAS_INIT_REF (pattern
);
6510 TYPE_HAS_CONST_INIT_REF (type
) = TYPE_HAS_CONST_INIT_REF (pattern
);
6511 TYPE_HAS_DEFAULT_CONSTRUCTOR (type
) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern
);
6512 TYPE_HAS_CONVERSION (type
) = TYPE_HAS_CONVERSION (pattern
);
6513 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
6514 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
6515 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
6516 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
6517 if (ANON_AGGR_TYPE_P (pattern
))
6518 SET_ANON_AGGR_TYPE_P (type
);
6519 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
6521 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
6522 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
6525 pbinfo
= TYPE_BINFO (pattern
);
6527 /* We should never instantiate a nested class before its enclosing
6528 class; we need to look up the nested class by name before we can
6529 instantiate it, and that lookup should instantiate the enclosing
6531 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
6532 || COMPLETE_TYPE_P (TYPE_CONTEXT (type
))
6533 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type
)));
6535 base_list
= NULL_TREE
;
6536 if (BINFO_N_BASE_BINFOS (pbinfo
))
6539 tree context
= TYPE_CONTEXT (type
);
6543 /* We must enter the scope containing the type, as that is where
6544 the accessibility of types named in dependent bases are
6546 pushed_scope
= push_scope (context
? context
: global_namespace
);
6548 /* Substitute into each of the bases to determine the actual
6550 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
6553 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
6554 tree expanded_bases
= NULL_TREE
;
6557 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
6560 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
6561 args
, tf_error
, NULL_TREE
);
6562 if (expanded_bases
== error_mark_node
)
6565 len
= TREE_VEC_LENGTH (expanded_bases
);
6568 for (idx
= 0; idx
< len
; idx
++)
6571 /* Extract the already-expanded base class. */
6572 base
= TREE_VEC_ELT (expanded_bases
, idx
);
6574 /* Substitute to figure out the base class. */
6575 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
6578 if (base
== error_mark_node
)
6581 base_list
= tree_cons (access
, base
, base_list
);
6582 if (BINFO_VIRTUAL_P (pbase_binfo
))
6583 TREE_TYPE (base_list
) = integer_type_node
;
6587 /* The list is now in reverse order; correct that. */
6588 base_list
= nreverse (base_list
);
6591 pop_scope (pushed_scope
);
6593 /* Now call xref_basetypes to set up all the base-class
6595 xref_basetypes (type
, base_list
);
6598 /* Now that our base classes are set up, enter the scope of the
6599 class, so that name lookups into base classes, etc. will work
6600 correctly. This is precisely analogous to what we do in
6601 begin_class_definition when defining an ordinary non-template
6605 /* Now members are processed in the order of declaration. */
6606 for (member
= CLASSTYPE_DECL_LIST (pattern
);
6607 member
; member
= TREE_CHAIN (member
))
6609 tree t
= TREE_VALUE (member
);
6611 if (TREE_PURPOSE (member
))
6615 /* Build new CLASSTYPE_NESTED_UTDS. */
6618 bool class_template_p
;
6620 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
6621 && TYPE_LANG_SPECIFIC (t
)
6622 && CLASSTYPE_IS_TEMPLATE (t
));
6623 /* If the member is a class template, then -- even after
6624 substitution -- there may be dependent types in the
6625 template argument list for the class. We increment
6626 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
6627 that function will assume that no types are dependent
6628 when outside of a template. */
6629 if (class_template_p
)
6630 ++processing_template_decl
;
6631 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
6632 if (class_template_p
)
6633 --processing_template_decl
;
6634 if (newtag
== error_mark_node
)
6637 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
6639 tree name
= TYPE_IDENTIFIER (t
);
6641 if (class_template_p
)
6642 /* Unfortunately, lookup_template_class sets
6643 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
6644 instantiation (i.e., for the type of a member
6645 template class nested within a template class.)
6646 This behavior is required for
6647 maybe_process_partial_specialization to work
6648 correctly, but is not accurate in this case;
6649 the TAG is not an instantiation of anything.
6650 (The corresponding TEMPLATE_DECL is an
6651 instantiation, but the TYPE is not.) */
6652 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
6654 /* Now, we call pushtag to put this NEWTAG into the scope of
6655 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
6656 pushtag calling push_template_decl. We don't have to do
6657 this for enums because it will already have been done in
6660 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
6661 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
6664 else if (TREE_CODE (t
) == FUNCTION_DECL
6665 || DECL_FUNCTION_TEMPLATE_P (t
))
6667 /* Build new TYPE_METHODS. */
6670 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6671 ++processing_template_decl
;
6672 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
6673 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6674 --processing_template_decl
;
6675 set_current_access_from_decl (r
);
6676 finish_member_declaration (r
);
6680 /* Build new TYPE_FIELDS. */
6681 if (TREE_CODE (t
) == STATIC_ASSERT
)
6684 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
6685 tf_warning_or_error
, NULL_TREE
,
6686 /*integral_constant_expression_p=*/true);
6687 finish_static_assert (condition
,
6688 STATIC_ASSERT_MESSAGE (t
),
6689 STATIC_ASSERT_SOURCE_LOCATION (t
),
6692 else if (TREE_CODE (t
) != CONST_DECL
)
6696 /* The the file and line for this declaration, to
6697 assist in error message reporting. Since we
6698 called push_tinst_level above, we don't need to
6700 input_location
= DECL_SOURCE_LOCATION (t
);
6702 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6703 ++processing_template_decl
;
6704 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
6705 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6706 --processing_template_decl
;
6707 if (TREE_CODE (r
) == VAR_DECL
)
6711 [t]he initialization (and any associated
6712 side-effects) of a static data member does
6713 not occur unless the static data member is
6714 itself used in a way that requires the
6715 definition of the static data member to
6718 Therefore, we do not substitute into the
6719 initialized for the static data member here. */
6720 finish_static_data_member_decl
6723 /*init_const_expr_p=*/false,
6724 /*asmspec_tree=*/NULL_TREE
,
6726 if (DECL_INITIALIZED_IN_CLASS_P (r
))
6727 check_static_variable_definition (r
, TREE_TYPE (r
));
6729 else if (TREE_CODE (r
) == FIELD_DECL
)
6731 /* Determine whether R has a valid type and can be
6732 completed later. If R is invalid, then it is
6733 replaced by error_mark_node so that it will not be
6734 added to TYPE_FIELDS. */
6735 tree rtype
= TREE_TYPE (r
);
6736 if (can_complete_type_without_circularity (rtype
))
6737 complete_type (rtype
);
6739 if (!COMPLETE_TYPE_P (rtype
))
6741 cxx_incomplete_type_error (r
, rtype
);
6742 r
= error_mark_node
;
6746 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
6747 such a thing will already have been added to the field
6748 list by tsubst_enum in finish_member_declaration in the
6749 CLASSTYPE_NESTED_UTDS case above. */
6750 if (!(TREE_CODE (r
) == TYPE_DECL
6751 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
6752 && DECL_ARTIFICIAL (r
)))
6754 set_current_access_from_decl (r
);
6755 finish_member_declaration (r
);
6762 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
))
6764 /* Build new CLASSTYPE_FRIEND_CLASSES. */
6766 tree friend_type
= t
;
6767 bool adjust_processing_template_decl
= false;
6769 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
6771 /* template <class T> friend class C; */
6772 friend_type
= tsubst_friend_class (friend_type
, args
);
6773 adjust_processing_template_decl
= true;
6775 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
6777 /* template <class T> friend class C::D; */
6778 friend_type
= tsubst (friend_type
, args
,
6779 tf_warning_or_error
, NULL_TREE
);
6780 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
6781 friend_type
= TREE_TYPE (friend_type
);
6782 adjust_processing_template_decl
= true;
6784 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
)
6786 /* This could be either
6790 when dependent_type_p is false or
6792 template <class U> friend class T::C;
6795 friend_type
= tsubst (friend_type
, args
,
6796 tf_warning_or_error
, NULL_TREE
);
6797 /* Bump processing_template_decl for correct
6798 dependent_type_p calculation. */
6799 ++processing_template_decl
;
6800 if (dependent_type_p (friend_type
))
6801 adjust_processing_template_decl
= true;
6802 --processing_template_decl
;
6804 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
6805 && hidden_name_p (TYPE_NAME (friend_type
)))
6809 where C hasn't been declared yet. Let's lookup name
6810 from namespace scope directly, bypassing any name that
6811 come from dependent base class. */
6812 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
6814 /* The call to xref_tag_from_type does injection for friend
6816 push_nested_namespace (ns
);
6818 xref_tag_from_type (friend_type
, NULL_TREE
,
6819 /*tag_scope=*/ts_current
);
6820 pop_nested_namespace (ns
);
6822 else if (uses_template_parms (friend_type
))
6823 /* friend class C<T>; */
6824 friend_type
= tsubst (friend_type
, args
,
6825 tf_warning_or_error
, NULL_TREE
);
6830 where C is already declared or
6832 friend class C<int>;
6834 We don't have to do anything in these cases. */
6836 if (adjust_processing_template_decl
)
6837 /* Trick make_friend_class into realizing that the friend
6838 we're adding is a template, not an ordinary class. It's
6839 important that we use make_friend_class since it will
6840 perform some error-checking and output cross-reference
6842 ++processing_template_decl
;
6844 if (friend_type
!= error_mark_node
)
6845 make_friend_class (type
, friend_type
, /*complain=*/false);
6847 if (adjust_processing_template_decl
)
6848 --processing_template_decl
;
6852 /* Build new DECL_FRIENDLIST. */
6855 /* The the file and line for this declaration, to
6856 assist in error message reporting. Since we
6857 called push_tinst_level above, we don't need to
6859 input_location
= DECL_SOURCE_LOCATION (t
);
6861 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6863 ++processing_template_decl
;
6864 push_deferring_access_checks (dk_no_check
);
6867 r
= tsubst_friend_function (t
, args
);
6868 add_friend (type
, r
, /*complain=*/false);
6869 if (TREE_CODE (t
) == TEMPLATE_DECL
)
6871 pop_deferring_access_checks ();
6872 --processing_template_decl
;
6878 /* Set the file and line number information to whatever is given for
6879 the class itself. This puts error messages involving generated
6880 implicit functions at a predictable point, and the same point
6881 that would be used for non-template classes. */
6882 input_location
= DECL_SOURCE_LOCATION (typedecl
);
6884 unreverse_member_declarations (type
);
6885 finish_struct_1 (type
);
6886 TYPE_BEING_DEFINED (type
) = 0;
6888 /* Now that the class is complete, instantiate default arguments for
6889 any member functions. We don't do this earlier because the
6890 default arguments may reference members of the class. */
6891 if (!PRIMARY_TEMPLATE_P (template))
6892 for (t
= TYPE_METHODS (type
); t
; t
= TREE_CHAIN (t
))
6893 if (TREE_CODE (t
) == FUNCTION_DECL
6894 /* Implicitly generated member functions will not have template
6895 information; they are not instantiations, but instead are
6896 created "fresh" for each instantiation. */
6897 && DECL_TEMPLATE_INFO (t
))
6898 tsubst_default_arguments (t
);
6901 pop_from_top_level ();
6902 pop_deferring_access_checks ();
6905 /* The vtable for a template class can be emitted in any translation
6906 unit in which the class is instantiated. When there is no key
6907 method, however, finish_struct_1 will already have added TYPE to
6908 the keyed_classes list. */
6909 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
6910 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
6916 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
6922 else if (TYPE_P (t
))
6923 r
= tsubst (t
, args
, complain
, in_decl
);
6926 r
= tsubst_expr (t
, args
, complain
, in_decl
,
6927 /*integral_constant_expression_p=*/true);
6928 r
= fold_non_dependent_expr (r
);
6933 /* Substitute ARGS into T, which is an pack expansion
6934 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
6935 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
6936 (if only a partial substitution could be performed) or
6937 ERROR_MARK_NODE if there was an error. */
6939 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
6943 tree pack
, packs
= NULL_TREE
, unsubstituted_packs
= NULL_TREE
;
6944 tree first_arg_pack
; int i
, len
= -1;
6948 gcc_assert (PACK_EXPANSION_P (t
));
6949 pattern
= PACK_EXPANSION_PATTERN (t
);
6951 /* Determine the argument packs that will instantiate the parameter
6952 packs used in the expansion expression. While we're at it,
6953 compute the number of arguments to be expanded and make sure it
6955 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
6956 pack
= TREE_CHAIN (pack
))
6958 tree parm_pack
= TREE_VALUE (pack
);
6959 tree arg_pack
= NULL_TREE
;
6960 tree orig_arg
= NULL_TREE
;
6962 if (TREE_CODE (parm_pack
) == PARM_DECL
)
6964 if (local_specializations
)
6965 arg_pack
= retrieve_local_specialization (parm_pack
);
6969 int level
, idx
, levels
;
6970 template_parm_level_and_index (parm_pack
, &level
, &idx
);
6972 levels
= TMPL_ARGS_DEPTH (args
);
6973 if (level
<= levels
)
6974 arg_pack
= TMPL_ARG (args
, level
, idx
);
6977 orig_arg
= arg_pack
;
6978 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
6979 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
6981 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
6982 /* This can only happen if we forget to expand an argument
6983 pack somewhere else. Just return an error, silently. */
6985 result
= make_tree_vec (1);
6986 TREE_VEC_ELT (result
, 0) = error_mark_node
;
6993 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
6995 /* It's all-or-nothing with incomplete argument packs. */
6996 if (incomplete
&& !ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
6997 return error_mark_node
;
6999 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
7005 first_arg_pack
= arg_pack
;
7007 else if (len
!= my_len
)
7009 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
7010 error ("mismatched argument pack lengths while expanding "
7014 error ("mismatched argument pack lengths while expanding "
7017 return error_mark_node
;
7020 /* Keep track of the parameter packs and their corresponding
7022 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
7023 TREE_TYPE (packs
) = orig_arg
;
7026 /* We can't substitute for this parameter pack. */
7027 unsubstituted_packs
= tree_cons (TREE_PURPOSE (pack
),
7029 unsubstituted_packs
);
7032 /* We cannot expand this expansion expression, because we don't have
7033 all of the argument packs we need. Substitute into the pattern
7034 and return a PACK_EXPANSION_*. The caller will need to deal with
7036 if (unsubstituted_packs
)
7037 return make_pack_expansion (tsubst (pattern
, args
, complain
,
7040 /* We could not find any argument packs that work. */
7042 return error_mark_node
;
7044 /* For each argument in each argument pack, substitute into the
7046 result
= make_tree_vec (len
+ incomplete
);
7047 for (i
= 0; i
< len
+ incomplete
; ++i
)
7049 /* For parameter pack, change the substitution of the parameter
7050 pack to the ith argument in its argument pack, then expand
7052 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
7054 tree parm
= TREE_PURPOSE (pack
);
7056 if (TREE_CODE (parm
) == PARM_DECL
)
7058 /* Select the Ith argument from the pack. */
7059 tree arg
= make_node (ARGUMENT_PACK_SELECT
);
7060 ARGUMENT_PACK_SELECT_FROM_PACK (arg
) = TREE_VALUE (pack
);
7061 ARGUMENT_PACK_SELECT_INDEX (arg
) = i
;
7063 register_local_specialization (arg
, parm
);
7069 template_parm_level_and_index (parm
, &level
, &idx
);
7073 /* Select the Ith argument from the pack. */
7074 value
= make_node (ARGUMENT_PACK_SELECT
);
7075 ARGUMENT_PACK_SELECT_FROM_PACK (value
) = TREE_VALUE (pack
);
7076 ARGUMENT_PACK_SELECT_INDEX (value
) = i
;
7079 /* Update the corresponding argument. */
7080 TMPL_ARG (args
, level
, idx
) = value
;
7084 /* Substitute into the PATTERN with the altered arguments. */
7085 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
7086 TREE_VEC_ELT (result
, i
) =
7087 tsubst_expr (pattern
, args
, complain
, in_decl
,
7088 /*integral_constant_expression_p=*/false);
7090 TREE_VEC_ELT (result
, i
) = tsubst (pattern
, args
, complain
, in_decl
);
7093 /* When we have incomplete argument packs, the last "expanded"
7094 result is itself a pack expansion, which allows us
7095 to deduce more arguments. */
7096 TREE_VEC_ELT (result
, i
) =
7097 make_pack_expansion (TREE_VEC_ELT (result
, i
));
7099 if (TREE_VEC_ELT (result
, i
) == error_mark_node
)
7101 result
= error_mark_node
;
7106 /* Update ARGS to restore the substitution from parameter packs to
7107 their argument packs. */
7108 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
7110 tree parm
= TREE_PURPOSE (pack
);
7112 if (TREE_CODE (parm
) == PARM_DECL
)
7113 register_local_specialization (TREE_TYPE (pack
), parm
);
7117 template_parm_level_and_index (parm
, &level
, &idx
);
7119 /* Update the corresponding argument. */
7120 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
7121 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
7124 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
7131 /* Substitute ARGS into the vector or list of template arguments T. */
7134 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
7137 int len
= TREE_VEC_LENGTH (t
);
7138 int need_new
= 0, i
, expanded_len_adjust
= 0, out
;
7139 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
7141 for (i
= 0; i
< len
; i
++)
7143 tree orig_arg
= TREE_VEC_ELT (t
, i
);
7146 if (TREE_CODE (orig_arg
) == TREE_VEC
)
7147 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
7148 else if (PACK_EXPANSION_P (orig_arg
))
7150 /* Substitute into an expansion expression. */
7151 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
7153 if (TREE_CODE (new_arg
) == TREE_VEC
)
7154 /* Add to the expanded length adjustment the number of
7155 expanded arguments. We subtract one from this
7156 measurement, because the argument pack expression
7157 itself is already counted as 1 in
7158 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7159 the argument pack is empty. */
7160 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
7162 else if (ARGUMENT_PACK_P (orig_arg
))
7164 /* Substitute into each of the arguments. */
7165 new_arg
= make_node (TREE_CODE (orig_arg
));
7167 SET_ARGUMENT_PACK_ARGS (
7169 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
7170 args
, complain
, in_decl
));
7172 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
7173 new_arg
= error_mark_node
;
7175 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
7176 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
7178 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
7180 if (TREE_TYPE (new_arg
) == error_mark_node
)
7181 new_arg
= error_mark_node
;
7185 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
7187 if (new_arg
== error_mark_node
)
7188 return error_mark_node
;
7191 if (new_arg
!= orig_arg
)
7198 /* Make space for the expanded arguments coming from template
7200 t
= make_tree_vec (len
+ expanded_len_adjust
);
7201 for (i
= 0, out
= 0; i
< len
; i
++)
7203 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
7204 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
7205 && TREE_CODE (elts
[i
]) == TREE_VEC
)
7209 /* Now expand the template argument pack "in place". */
7210 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
7211 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
7215 TREE_VEC_ELT (t
, out
) = elts
[i
];
7223 /* Return the result of substituting ARGS into the template parameters
7224 given by PARMS. If there are m levels of ARGS and m + n levels of
7225 PARMS, then the result will contain n levels of PARMS. For
7226 example, if PARMS is `template <class T> template <class U>
7227 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7228 result will be `template <int*, double, class V>'. */
7231 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
7236 /* When substituting into a template, we must set
7237 PROCESSING_TEMPLATE_DECL as the template parameters may be
7238 dependent if they are based on one-another, and the dependency
7239 predicates are short-circuit outside of templates. */
7240 ++processing_template_decl
;
7242 for (new_parms
= &r
;
7243 TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
7244 new_parms
= &(TREE_CHAIN (*new_parms
)),
7245 parms
= TREE_CHAIN (parms
))
7248 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
7251 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
7257 if (parms
== error_mark_node
)
7260 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
7262 if (tuple
== error_mark_node
)
7265 default_value
= TREE_PURPOSE (tuple
);
7266 parm_decl
= TREE_VALUE (tuple
);
7268 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
7269 if (TREE_CODE (parm_decl
) == PARM_DECL
7270 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
7271 parm_decl
= error_mark_node
;
7272 default_value
= tsubst_template_arg (default_value
, args
,
7273 complain
, NULL_TREE
);
7275 tuple
= build_tree_list (default_value
, parm_decl
);
7276 TREE_VEC_ELT (new_vec
, i
) = tuple
;
7280 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
7281 - TMPL_ARGS_DEPTH (args
)),
7282 new_vec
, NULL_TREE
);
7285 --processing_template_decl
;
7290 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7291 type T. If T is not an aggregate or enumeration type, it is
7292 handled as if by tsubst. IN_DECL is as for tsubst. If
7293 ENTERING_SCOPE is nonzero, T is the context for a template which
7294 we are presently tsubst'ing. Return the substituted value. */
7297 tsubst_aggr_type (tree t
,
7299 tsubst_flags_t complain
,
7306 switch (TREE_CODE (t
))
7309 if (TYPE_PTRMEMFUNC_P (t
))
7310 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
7312 /* Else fall through. */
7315 if (TYPE_TEMPLATE_INFO (t
))
7320 bool saved_skip_evaluation
;
7322 /* In "sizeof(X<I>)" we need to evaluate "I". */
7323 saved_skip_evaluation
= skip_evaluation
;
7324 skip_evaluation
= false;
7326 /* First, determine the context for the type we are looking
7328 context
= TYPE_CONTEXT (t
);
7330 context
= tsubst_aggr_type (context
, args
, complain
,
7331 in_decl
, /*entering_scope=*/1);
7333 /* Then, figure out what arguments are appropriate for the
7334 type we are trying to find. For example, given:
7336 template <class T> struct S;
7337 template <class T, class U> void f(T, U) { S<U> su; }
7339 and supposing that we are instantiating f<int, double>,
7340 then our ARGS will be {int, double}, but, when looking up
7341 S we only want {double}. */
7342 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
7344 if (argvec
== error_mark_node
)
7345 r
= error_mark_node
;
7348 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
7349 entering_scope
, complain
);
7350 r
= cp_build_qualified_type_real (r
, TYPE_QUALS (t
), complain
);
7353 skip_evaluation
= saved_skip_evaluation
;
7358 /* This is not a template type, so there's nothing to do. */
7362 return tsubst (t
, args
, complain
, in_decl
);
7366 /* Substitute into the default argument ARG (a default argument for
7367 FN), which has the indicated TYPE. */
7370 tsubst_default_argument (tree fn
, tree type
, tree arg
)
7372 tree saved_class_ptr
= NULL_TREE
;
7373 tree saved_class_ref
= NULL_TREE
;
7375 /* This default argument came from a template. Instantiate the
7376 default argument here, not in tsubst. In the case of
7385 we must be careful to do name lookup in the scope of S<T>,
7386 rather than in the current class. */
7387 push_access_scope (fn
);
7388 /* The "this" pointer is not valid in a default argument. */
7391 saved_class_ptr
= current_class_ptr
;
7392 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
7393 saved_class_ref
= current_class_ref
;
7394 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
7397 push_deferring_access_checks(dk_no_deferred
);
7398 /* The default argument expression may cause implicitly defined
7399 member functions to be synthesized, which will result in garbage
7400 collection. We must treat this situation as if we were within
7401 the body of function so as to avoid collecting live data on the
7404 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
7405 tf_warning_or_error
, NULL_TREE
,
7406 /*integral_constant_expression_p=*/false);
7408 pop_deferring_access_checks();
7410 /* Restore the "this" pointer. */
7413 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
7414 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
7417 pop_access_scope (fn
);
7419 /* Make sure the default argument is reasonable. */
7420 arg
= check_default_argument (type
, arg
);
7425 /* Substitute into all the default arguments for FN. */
7428 tsubst_default_arguments (tree fn
)
7433 tmpl_args
= DECL_TI_ARGS (fn
);
7435 /* If this function is not yet instantiated, we certainly don't need
7436 its default arguments. */
7437 if (uses_template_parms (tmpl_args
))
7440 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7442 arg
= TREE_CHAIN (arg
))
7443 if (TREE_PURPOSE (arg
))
7444 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
7446 TREE_PURPOSE (arg
));
7449 /* Substitute the ARGS into the T, which is a _DECL. Return the
7450 result of the substitution. Issue error and warning messages under
7451 control of COMPLAIN. */
7454 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
7456 location_t saved_loc
;
7460 /* Set the filename and linenumber to improve error-reporting. */
7461 saved_loc
= input_location
;
7462 input_location
= DECL_SOURCE_LOCATION (t
);
7464 switch (TREE_CODE (t
))
7468 /* We can get here when processing a member function template,
7469 member class template, and template template parameter of
7470 a template class. */
7471 tree decl
= DECL_TEMPLATE_RESULT (t
);
7476 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
7478 /* Template template parameter is treated here. */
7479 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7480 if (new_type
== error_mark_node
)
7481 return error_mark_node
;
7484 TREE_CHAIN (r
) = NULL_TREE
;
7485 TREE_TYPE (r
) = new_type
;
7486 DECL_TEMPLATE_RESULT (r
)
7487 = build_decl (TYPE_DECL
, DECL_NAME (decl
), new_type
);
7488 DECL_TEMPLATE_PARMS (r
)
7489 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
7491 TYPE_NAME (new_type
) = r
;
7495 /* We might already have an instance of this template.
7496 The ARGS are for the surrounding class type, so the
7497 full args contain the tsubst'd args for the context,
7498 plus the innermost args from the template decl. */
7499 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
7500 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
7501 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
7502 /* Because this is a template, the arguments will still be
7503 dependent, even after substitution. If
7504 PROCESSING_TEMPLATE_DECL is not set, the dependency
7505 predicates will short-circuit. */
7506 ++processing_template_decl
;
7507 full_args
= tsubst_template_args (tmpl_args
, args
,
7509 --processing_template_decl
;
7510 if (full_args
== error_mark_node
)
7511 return error_mark_node
;
7513 /* tsubst_template_args doesn't copy the vector if
7514 nothing changed. But, *something* should have
7516 gcc_assert (full_args
!= tmpl_args
);
7518 spec
= retrieve_specialization (t
, full_args
,
7519 /*class_specializations_p=*/true);
7520 if (spec
!= NULL_TREE
)
7526 /* Make a new template decl. It will be similar to the
7527 original, but will record the current template arguments.
7528 We also create a new function declaration, which is just
7529 like the old one, but points to this new template, rather
7530 than the old one. */
7532 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
7533 TREE_CHAIN (r
) = NULL_TREE
;
7535 DECL_TEMPLATE_INFO (r
) = build_tree_list (t
, args
);
7537 if (TREE_CODE (decl
) == TYPE_DECL
)
7540 ++processing_template_decl
;
7541 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7542 --processing_template_decl
;
7543 if (new_type
== error_mark_node
)
7544 return error_mark_node
;
7546 TREE_TYPE (r
) = new_type
;
7547 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
7548 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
7549 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
7550 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
7555 ++processing_template_decl
;
7556 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
7557 --processing_template_decl
;
7558 if (new_decl
== error_mark_node
)
7559 return error_mark_node
;
7561 DECL_TEMPLATE_RESULT (r
) = new_decl
;
7562 DECL_TI_TEMPLATE (new_decl
) = r
;
7563 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
7564 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
7565 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
7568 SET_DECL_IMPLICIT_INSTANTIATION (r
);
7569 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
7570 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
7572 /* The template parameters for this new template are all the
7573 template parameters for the old template, except the
7574 outermost level of parameters. */
7575 DECL_TEMPLATE_PARMS (r
)
7576 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
7579 if (PRIMARY_TEMPLATE_P (t
))
7580 DECL_PRIMARY_TEMPLATE (r
) = r
;
7582 if (TREE_CODE (decl
) != TYPE_DECL
)
7583 /* Record this non-type partial instantiation. */
7584 register_specialization (r
, t
,
7585 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
7593 tree argvec
= NULL_TREE
;
7601 /* Nobody should be tsubst'ing into non-template functions. */
7602 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
7604 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
7609 /* If T is not dependent, just return it. We have to
7610 increment PROCESSING_TEMPLATE_DECL because
7611 value_dependent_expression_p assumes that nothing is
7612 dependent when PROCESSING_TEMPLATE_DECL is zero. */
7613 ++processing_template_decl
;
7614 dependent_p
= value_dependent_expression_p (t
);
7615 --processing_template_decl
;
7619 /* Calculate the most general template of which R is a
7620 specialization, and the complete set of arguments used to
7622 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
7623 argvec
= tsubst_template_args (DECL_TI_ARGS
7624 (DECL_TEMPLATE_RESULT (gen_tmpl
)),
7625 args
, complain
, in_decl
);
7627 /* Check to see if we already have this specialization. */
7628 spec
= retrieve_specialization (gen_tmpl
, argvec
,
7629 /*class_specializations_p=*/false);
7637 /* We can see more levels of arguments than parameters if
7638 there was a specialization of a member template, like
7641 template <class T> struct S { template <class U> void f(); }
7642 template <> template <class U> void S<int>::f(U);
7644 Here, we'll be substituting into the specialization,
7645 because that's where we can find the code we actually
7646 want to generate, but we'll have enough arguments for
7647 the most general template.
7649 We also deal with the peculiar case:
7651 template <class T> struct S {
7652 template <class U> friend void f();
7654 template <class U> void f() {}
7656 template void f<double>();
7658 Here, the ARGS for the instantiation of will be {int,
7659 double}. But, we only need as many ARGS as there are
7660 levels of template parameters in CODE_PATTERN. We are
7661 careful not to get fooled into reducing the ARGS in
7664 template <class T> struct S { template <class U> void f(U); }
7665 template <class T> template <> void S<T>::f(int) {}
7667 which we can spot because the pattern will be a
7668 specialization in this case. */
7669 args_depth
= TMPL_ARGS_DEPTH (args
);
7671 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
7672 if (args_depth
> parms_depth
7673 && !DECL_TEMPLATE_SPECIALIZATION (t
))
7674 args
= get_innermost_template_args (args
, parms_depth
);
7678 /* This special case arises when we have something like this:
7680 template <class T> struct S {
7681 friend void f<int>(int, double);
7684 Here, the DECL_TI_TEMPLATE for the friend declaration
7685 will be an IDENTIFIER_NODE. We are being called from
7686 tsubst_friend_function, and we want only to create a
7687 new decl (R) with appropriate types so that we can call
7688 determine_specialization. */
7689 gen_tmpl
= NULL_TREE
;
7692 if (DECL_CLASS_SCOPE_P (t
))
7694 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
7698 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
7699 complain
, t
, /*entering_scope=*/1);
7704 ctx
= DECL_CONTEXT (t
);
7706 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7707 if (type
== error_mark_node
)
7708 return error_mark_node
;
7710 /* We do NOT check for matching decls pushed separately at this
7711 point, as they may not represent instantiations of this
7712 template, and in any case are considered separate under the
7715 DECL_USE_TEMPLATE (r
) = 0;
7716 TREE_TYPE (r
) = type
;
7717 /* Clear out the mangled name and RTL for the instantiation. */
7718 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
7719 SET_DECL_RTL (r
, NULL_RTX
);
7720 DECL_INITIAL (r
) = NULL_TREE
;
7721 DECL_CONTEXT (r
) = ctx
;
7723 if (member
&& DECL_CONV_FN_P (r
))
7724 /* Type-conversion operator. Reconstruct the name, in
7725 case it's the name of one of the template's parameters. */
7726 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
7728 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
7730 DECL_RESULT (r
) = NULL_TREE
;
7732 TREE_STATIC (r
) = 0;
7733 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
7734 DECL_EXTERNAL (r
) = 1;
7735 /* If this is an instantiation of a function with internal
7736 linkage, we already know what object file linkage will be
7737 assigned to the instantiation. */
7738 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
7739 DECL_DEFER_OUTPUT (r
) = 0;
7740 TREE_CHAIN (r
) = NULL_TREE
;
7741 DECL_PENDING_INLINE_INFO (r
) = 0;
7742 DECL_PENDING_INLINE_P (r
) = 0;
7743 DECL_SAVED_TREE (r
) = NULL_TREE
;
7745 if (DECL_CLONED_FUNCTION (r
))
7747 DECL_CLONED_FUNCTION (r
) = tsubst (DECL_CLONED_FUNCTION (t
),
7749 TREE_CHAIN (r
) = TREE_CHAIN (DECL_CLONED_FUNCTION (r
));
7750 TREE_CHAIN (DECL_CLONED_FUNCTION (r
)) = r
;
7753 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
7754 this in the special friend case mentioned above where
7755 GEN_TMPL is NULL. */
7758 DECL_TEMPLATE_INFO (r
)
7759 = tree_cons (gen_tmpl
, argvec
, NULL_TREE
);
7760 SET_DECL_IMPLICIT_INSTANTIATION (r
);
7761 register_specialization (r
, gen_tmpl
, argvec
, false);
7763 /* We're not supposed to instantiate default arguments
7764 until they are called, for a template. But, for a
7767 template <class T> void f ()
7768 { extern void g(int i = T()); }
7770 we should do the substitution when the template is
7771 instantiated. We handle the member function case in
7772 instantiate_class_template since the default arguments
7773 might refer to other members of the class. */
7775 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
7776 && !uses_template_parms (argvec
))
7777 tsubst_default_arguments (r
);
7780 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
7782 /* Copy the list of befriending classes. */
7783 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
7785 friends
= &TREE_CHAIN (*friends
))
7787 *friends
= copy_node (*friends
);
7788 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
7793 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
7795 maybe_retrofit_in_chrg (r
);
7796 if (DECL_CONSTRUCTOR_P (r
))
7797 grok_ctor_properties (ctx
, r
);
7798 /* If this is an instantiation of a member template, clone it.
7799 If it isn't, that'll be handled by
7800 clone_constructors_and_destructors. */
7801 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
7802 clone_function_decl (r
, /*update_method_vec_p=*/0);
7804 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r
))
7805 && !grok_op_properties (r
, (complain
& tf_error
) != 0))
7806 return error_mark_node
;
7808 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
7809 SET_DECL_FRIEND_CONTEXT (r
,
7810 tsubst (DECL_FRIEND_CONTEXT (t
),
7811 args
, complain
, in_decl
));
7813 /* Possibly limit visibility based on template args. */
7814 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
7815 if (DECL_VISIBILITY_SPECIFIED (t
))
7817 DECL_VISIBILITY_SPECIFIED (r
) = 0;
7819 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
7821 determine_visibility (r
);
7827 tree type
= NULL_TREE
;
7829 tree expanded_types
= NULL_TREE
;
7830 tree prev_r
= NULL_TREE
;
7831 tree first_r
= NULL_TREE
;
7833 if (FUNCTION_PARAMETER_PACK_P (t
))
7835 /* If there is a local specialization that isn't a
7836 parameter pack, it means that we're doing a "simple"
7837 substitution from inside tsubst_pack_expansion. Just
7838 return the local specialization (which will be a single
7840 tree spec
= NULL_TREE
;
7841 if (local_specializations
)
7842 spec
= retrieve_local_specialization (t
);
7844 && TREE_CODE (spec
) == PARM_DECL
7845 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
7848 /* Expand the TYPE_PACK_EXPANSION that provides the types for
7849 the parameters in this function parameter pack. */
7850 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
7852 if (TREE_CODE (expanded_types
) == TREE_VEC
)
7854 len
= TREE_VEC_LENGTH (expanded_types
);
7856 /* Zero-length parameter packs are boring. Just substitute
7859 return tsubst (TREE_CHAIN (t
), args
, complain
,
7864 /* All we did was update the type. Make a note of that. */
7865 type
= expanded_types
;
7866 expanded_types
= NULL_TREE
;
7870 /* Loop through all of the parameter's we'll build. When T is
7871 a function parameter pack, LEN is the number of expanded
7872 types in EXPANDED_TYPES; otherwise, LEN is 1. */
7874 for (i
= 0; i
< len
; ++i
)
7878 if (DECL_TEMPLATE_PARM_P (t
))
7879 SET_DECL_TEMPLATE_PARM_P (r
);
7882 /* We're on the Ith parameter of the function parameter
7885 /* Get the Ith type. */
7886 type
= TREE_VEC_ELT (expanded_types
, i
);
7889 /* Rename the parameter to include the index. */
7891 make_ith_pack_parameter_name (DECL_NAME (r
), i
);
7894 /* We're dealing with a normal parameter. */
7895 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7897 type
= type_decays_to (type
);
7898 TREE_TYPE (r
) = type
;
7899 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
7901 if (DECL_INITIAL (r
))
7903 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
7904 DECL_INITIAL (r
) = TREE_TYPE (r
);
7906 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
7910 DECL_CONTEXT (r
) = NULL_TREE
;
7912 if (!DECL_TEMPLATE_PARM_P (r
))
7913 DECL_ARG_TYPE (r
) = type_passed_as (type
);
7915 /* Keep track of the first new parameter we
7916 generate. That's what will be returned to the
7921 /* Build a proper chain of parameters when substituting
7922 into a function parameter pack. */
7924 TREE_CHAIN (prev_r
) = r
;
7928 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
,
7929 complain
, TREE_CHAIN (t
));
7931 /* FIRST_R contains the start of the chain we've built. */
7941 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7942 if (type
== error_mark_node
)
7943 return error_mark_node
;
7944 TREE_TYPE (r
) = type
;
7945 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
7947 /* DECL_INITIAL gives the number of bits in a bit-field. */
7949 = tsubst_expr (DECL_INITIAL (t
), args
,
7951 /*integral_constant_expression_p=*/true);
7952 /* We don't have to set DECL_CONTEXT here; it is set by
7953 finish_member_declaration. */
7954 TREE_CHAIN (r
) = NULL_TREE
;
7955 if (VOID_TYPE_P (type
))
7956 error ("instantiation of %q+D as type %qT", r
, type
);
7961 /* We reach here only for member using decls. */
7962 if (DECL_DEPENDENT_P (t
))
7964 r
= do_class_using_decl
7965 (tsubst_copy (USING_DECL_SCOPE (t
), args
, complain
, in_decl
),
7966 tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
));
7968 r
= error_mark_node
;
7973 TREE_CHAIN (r
) = NULL_TREE
;
7980 tree argvec
= NULL_TREE
;
7981 tree gen_tmpl
= NULL_TREE
;
7983 tree tmpl
= NULL_TREE
;
7985 tree type
= NULL_TREE
;
7988 if (TREE_CODE (t
) == TYPE_DECL
)
7990 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7991 if (TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
7992 || t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
7994 /* If this is the canonical decl, we don't have to
7995 mess with instantiations, and often we can't (for
7996 typename, template type parms and such). Note that
7997 TYPE_NAME is not correct for the above test if
7998 we've copied the type for a typedef. */
7999 r
= TYPE_NAME (type
);
8004 /* Check to see if we already have the specialization we
8007 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
8009 /* T is a static data member or namespace-scope entity.
8010 We have to substitute into namespace-scope variables
8011 (even though such entities are never templates) because
8014 template <class T> void f() { extern T t; }
8016 where the entity referenced is not known until
8017 instantiation time. */
8019 ctx
= DECL_CONTEXT (t
);
8020 if (DECL_CLASS_SCOPE_P (t
))
8022 ctx
= tsubst_aggr_type (ctx
, args
,
8024 in_decl
, /*entering_scope=*/1);
8025 /* If CTX is unchanged, then T is in fact the
8026 specialization we want. That situation occurs when
8027 referencing a static data member within in its own
8028 class. We can use pointer equality, rather than
8029 same_type_p, because DECL_CONTEXT is always
8031 if (ctx
== DECL_CONTEXT (t
))
8037 tmpl
= DECL_TI_TEMPLATE (t
);
8038 gen_tmpl
= most_general_template (tmpl
);
8039 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
8040 spec
= (retrieve_specialization
8042 /*class_specializations_p=*/false));
8047 /* A local variable. */
8049 /* Subsequent calls to pushdecl will fill this in. */
8051 spec
= retrieve_local_specialization (t
);
8053 /* If we already have the specialization we need, there is
8054 nothing more to do. */
8061 /* Create a new node for the specialization we need. */
8063 if (TREE_CODE (r
) == VAR_DECL
)
8065 /* Even if the original location is out of scope, the
8066 newly substituted one is not. */
8067 DECL_DEAD_FOR_LOCAL (r
) = 0;
8068 DECL_INITIALIZED_P (r
) = 0;
8069 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
8070 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8071 if (type
== error_mark_node
)
8072 return error_mark_node
;
8073 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8075 /* It may seem that this case cannot occur, since:
8080 declares a function, not a variable. However:
8083 template <typename T> void g() { T t; }
8084 template void g<f>();
8086 is an attempt to declare a variable with function
8088 error ("variable %qD has function type",
8089 /* R is not yet sufficiently initialized, so we
8090 just use its name. */
8092 return error_mark_node
;
8094 type
= complete_type (type
);
8095 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
8096 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
);
8097 type
= check_var_type (DECL_NAME (r
), type
);
8099 if (DECL_HAS_VALUE_EXPR_P (t
))
8101 tree ve
= DECL_VALUE_EXPR (t
);
8102 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
8103 /*constant_expression_p=*/false);
8104 SET_DECL_VALUE_EXPR (r
, ve
);
8107 else if (DECL_SELF_REFERENCE_P (t
))
8108 SET_DECL_SELF_REFERENCE_P (r
);
8109 TREE_TYPE (r
) = type
;
8110 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
8111 DECL_CONTEXT (r
) = ctx
;
8112 /* Clear out the mangled name and RTL for the instantiation. */
8113 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
8114 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
8115 SET_DECL_RTL (r
, NULL_RTX
);
8116 /* The initializer must not be expanded until it is required;
8118 DECL_INITIAL (r
) = NULL_TREE
;
8119 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
8120 SET_DECL_RTL (r
, NULL_RTX
);
8121 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
8122 if (TREE_CODE (r
) == VAR_DECL
)
8124 /* Possibly limit visibility based on template args. */
8125 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
8126 if (DECL_VISIBILITY_SPECIFIED (t
))
8128 DECL_VISIBILITY_SPECIFIED (r
) = 0;
8130 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
8132 determine_visibility (r
);
8137 /* A static data member declaration is always marked
8138 external when it is declared in-class, even if an
8139 initializer is present. We mimic the non-template
8141 DECL_EXTERNAL (r
) = 1;
8143 register_specialization (r
, gen_tmpl
, argvec
, false);
8144 DECL_TEMPLATE_INFO (r
) = tree_cons (tmpl
, argvec
, NULL_TREE
);
8145 SET_DECL_IMPLICIT_INSTANTIATION (r
);
8148 register_local_specialization (r
, t
);
8150 TREE_CHAIN (r
) = NULL_TREE
;
8159 /* Restore the file and line information. */
8160 input_location
= saved_loc
;
8165 /* Substitute into the ARG_TYPES of a function type. */
8168 tsubst_arg_types (tree arg_types
,
8170 tsubst_flags_t complain
,
8173 tree remaining_arg_types
;
8174 tree type
= NULL_TREE
;
8176 tree expanded_args
= NULL_TREE
;
8179 if (!arg_types
|| arg_types
== void_list_node
)
8182 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
8183 args
, complain
, in_decl
);
8184 if (remaining_arg_types
== error_mark_node
)
8185 return error_mark_node
;
8187 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
8189 /* For a pack expansion, perform substitution on the
8190 entire expression. Later on, we'll handle the arguments
8192 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
8193 args
, complain
, in_decl
);
8195 if (TREE_CODE (expanded_args
) == TREE_VEC
)
8196 /* So that we'll spin through the parameters, one by one. */
8197 i
= TREE_VEC_LENGTH (expanded_args
);
8200 /* We only partially substituted into the parameter
8201 pack. Our type is TYPE_PACK_EXPANSION. */
8202 type
= expanded_args
;
8203 expanded_args
= NULL_TREE
;
8211 type
= TREE_VEC_ELT (expanded_args
, i
);
8213 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
8215 if (type
== error_mark_node
)
8216 return error_mark_node
;
8217 if (VOID_TYPE_P (type
))
8219 if (complain
& tf_error
)
8221 error ("invalid parameter type %qT", type
);
8223 error ("in declaration %q+D", in_decl
);
8225 return error_mark_node
;
8228 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8229 top-level qualifiers as required. */
8230 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
8232 /* We do not substitute into default arguments here. The standard
8233 mandates that they be instantiated only when needed, which is
8234 done in build_over_call. */
8235 default_arg
= TREE_PURPOSE (arg_types
);
8237 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
8239 /* We've instantiated a template before its default arguments
8240 have been parsed. This can happen for a nested template
8241 class, and is not an error unless we require the default
8242 argument in a call of this function. */
8243 remaining_arg_types
=
8244 tree_cons (default_arg
, type
, remaining_arg_types
);
8245 VEC_safe_push (tree
, gc
, DEFARG_INSTANTIATIONS (default_arg
),
8246 remaining_arg_types
);
8249 remaining_arg_types
=
8250 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
8253 return remaining_arg_types
;
8256 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8257 *not* handle the exception-specification for FNTYPE, because the
8258 initial substitution of explicitly provided template parameters
8259 during argument deduction forbids substitution into the
8260 exception-specification:
8264 All references in the function type of the function template to the
8265 corresponding template parameters are replaced by the specified tem-
8266 plate argument values. If a substitution in a template parameter or
8267 in the function type of the function template results in an invalid
8268 type, type deduction fails. [Note: The equivalent substitution in
8269 exception specifications is done only when the function is instanti-
8270 ated, at which point a program is ill-formed if the substitution
8271 results in an invalid type.] */
8274 tsubst_function_type (tree t
,
8276 tsubst_flags_t complain
,
8283 /* The TYPE_CONTEXT is not used for function/method types. */
8284 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
8286 /* Substitute the return type. */
8287 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8288 if (return_type
== error_mark_node
)
8289 return error_mark_node
;
8290 /* The standard does not presently indicate that creation of a
8291 function type with an invalid return type is a deduction failure.
8292 However, that is clearly analogous to creating an array of "void"
8293 or a reference to a reference. This is core issue #486. */
8294 if (TREE_CODE (return_type
) == ARRAY_TYPE
8295 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
8297 if (complain
& tf_error
)
8299 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
8300 error ("function returning an array");
8302 error ("function returning a function");
8304 return error_mark_node
;
8307 /* Substitute the argument types. */
8308 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
,
8310 if (arg_types
== error_mark_node
)
8311 return error_mark_node
;
8313 if (TYPE_QUALS (return_type
) != TYPE_UNQUALIFIED
8314 && in_decl
!= NULL_TREE
8315 && !TREE_NO_WARNING (in_decl
)
8316 && (SCALAR_TYPE_P (return_type
) || VOID_TYPE_P (return_type
)))
8317 warning (OPT_Wreturn_type
,
8318 "type qualifiers ignored on function return type");
8320 /* Construct a new type node and return it. */
8321 if (TREE_CODE (t
) == FUNCTION_TYPE
)
8322 fntype
= build_function_type (return_type
, arg_types
);
8325 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
8326 if (! IS_AGGR_TYPE (r
))
8330 Type deduction may fail for any of the following
8333 -- Attempting to create "pointer to member of T" when T
8334 is not a class type. */
8335 if (complain
& tf_error
)
8336 error ("creating pointer to member function of non-class type %qT",
8338 return error_mark_node
;
8341 fntype
= build_method_type_directly (r
, return_type
,
8342 TREE_CHAIN (arg_types
));
8344 fntype
= cp_build_qualified_type_real (fntype
, TYPE_QUALS (t
), complain
);
8345 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
8350 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8351 ARGS into that specification, and return the substituted
8352 specification. If there is no specification, return NULL_TREE. */
8355 tsubst_exception_specification (tree fntype
,
8357 tsubst_flags_t complain
,
8363 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
8364 new_specs
= NULL_TREE
;
8367 if (! TREE_VALUE (specs
))
8374 tree expanded_specs
= NULL_TREE
;
8376 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
8378 /* Expand the pack expansion type. */
8379 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
8382 len
= TREE_VEC_LENGTH (expanded_specs
);
8385 for (i
= 0; i
< len
; ++i
)
8388 spec
= TREE_VEC_ELT (expanded_specs
, i
);
8390 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
8391 if (spec
== error_mark_node
)
8393 new_specs
= add_exception_specifier (new_specs
, spec
,
8397 specs
= TREE_CHAIN (specs
);
8403 /* Take the tree structure T and replace template parameters used
8404 therein with the argument vector ARGS. IN_DECL is an associated
8405 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8406 Issue error and warning messages under control of COMPLAIN. Note
8407 that we must be relatively non-tolerant of extensions here, in
8408 order to preserve conformance; if we allow substitutions that
8409 should not be allowed, we may allow argument deductions that should
8410 not succeed, and therefore report ambiguous overload situations
8411 where there are none. In theory, we could allow the substitution,
8412 but indicate that it should have failed, and allow our caller to
8413 make sure that the right thing happens, but we don't try to do this
8416 This function is used for dealing with types, decls and the like;
8417 for expressions, use tsubst_expr or tsubst_copy. */
8420 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
8424 if (t
== NULL_TREE
|| t
== error_mark_node
8425 || t
== integer_type_node
8426 || t
== void_type_node
8427 || t
== char_type_node
8428 || t
== unknown_type_node
8429 || TREE_CODE (t
) == NAMESPACE_DECL
)
8433 return tsubst_decl (t
, args
, complain
);
8435 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
8436 type
= IDENTIFIER_TYPE_VALUE (t
);
8438 type
= TREE_TYPE (t
);
8440 gcc_assert (type
!= unknown_type_node
);
8443 && TREE_CODE (t
) != TYPENAME_TYPE
8444 && TREE_CODE (t
) != IDENTIFIER_NODE
8445 && TREE_CODE (t
) != FUNCTION_TYPE
8446 && TREE_CODE (t
) != METHOD_TYPE
)
8447 type
= tsubst (type
, args
, complain
, in_decl
);
8448 if (type
== error_mark_node
)
8449 return error_mark_node
;
8451 switch (TREE_CODE (t
))
8456 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
8457 /*entering_scope=*/0);
8460 case IDENTIFIER_NODE
:
8472 if (t
== integer_type_node
)
8475 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
8476 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
8480 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
8482 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
8483 /*integral_constant_expression_p=*/false);
8484 max
= fold_decl_constant_value (max
);
8486 if (TREE_CODE (max
) != INTEGER_CST
8487 && TREE_CODE (max
) != TEMPLATE_PARM_INDEX
8488 && !at_function_scope_p ())
8490 if (complain
& tf_error
)
8491 error ("array bound is not an integer constant");
8492 return error_mark_node
;
8497 Type deduction may fail for any of the following
8500 Attempting to create an array with a size that is
8501 zero or negative. */
8502 if (integer_zerop (max
) && !(complain
& tf_error
))
8503 /* We must fail if performing argument deduction (as
8504 indicated by the state of complain), so that
8505 another substitution can be found. */
8506 return error_mark_node
;
8507 else if (TREE_CODE (max
) == INTEGER_CST
8508 && INT_CST_LT (max
, integer_zero_node
))
8510 if (complain
& tf_error
)
8511 error ("creating array with negative size (%qE)", max
);
8513 return error_mark_node
;
8516 return compute_array_index_type (NULL_TREE
, max
);
8519 case TEMPLATE_TYPE_PARM
:
8520 case TEMPLATE_TEMPLATE_PARM
:
8521 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8522 case TEMPLATE_PARM_INDEX
:
8527 tree arg
= NULL_TREE
;
8531 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
8532 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
8533 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
8534 || TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
8536 idx
= TEMPLATE_TYPE_IDX (t
);
8537 level
= TEMPLATE_TYPE_LEVEL (t
);
8541 idx
= TEMPLATE_PARM_IDX (t
);
8542 level
= TEMPLATE_PARM_LEVEL (t
);
8545 levels
= TMPL_ARGS_DEPTH (args
);
8546 if (level
<= levels
)
8548 arg
= TMPL_ARG (args
, level
, idx
);
8550 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
8551 /* See through ARGUMENT_PACK_SELECT arguments. */
8552 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
8555 if (arg
== error_mark_node
)
8556 return error_mark_node
;
8557 else if (arg
!= NULL_TREE
)
8559 if (ARGUMENT_PACK_P (arg
))
8560 /* If ARG is an argument pack, we don't actually want to
8561 perform a substitution here, because substitutions
8562 for argument packs are only done
8563 element-by-element. We can get to this point when
8564 substituting the type of a non-type template
8565 parameter pack, when that type actually contains
8566 template parameter packs from an outer template, e.g.,
8568 template<typename... Types> struct A {
8569 template<Types... Values> struct B { };
8573 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
8576 gcc_assert (TYPE_P (arg
));
8578 /* cv-quals from the template are discarded when
8579 substituting in a function or reference type. */
8580 if (TREE_CODE (arg
) == FUNCTION_TYPE
8581 || TREE_CODE (arg
) == METHOD_TYPE
8582 || TREE_CODE (arg
) == REFERENCE_TYPE
)
8583 quals
= cp_type_quals (arg
);
8585 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
8587 return cp_build_qualified_type_real
8588 (arg
, quals
, complain
| tf_ignore_bad_quals
);
8590 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
8592 /* We are processing a type constructed from a
8593 template template parameter. */
8594 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
8595 args
, complain
, in_decl
);
8596 if (argvec
== error_mark_node
)
8597 return error_mark_node
;
8599 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
8600 are resolving nested-types in the signature of a
8601 member function templates. Otherwise ARG is a
8602 TEMPLATE_DECL and is the real template to be
8604 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
8605 arg
= TYPE_NAME (arg
);
8607 r
= lookup_template_class (arg
,
8610 /*entering_scope=*/0,
8612 return cp_build_qualified_type_real
8613 (r
, TYPE_QUALS (t
), complain
);
8616 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
8621 /* This can happen during the attempted tsubst'ing in
8622 unify. This means that we don't yet have any information
8623 about the template parameter in question. */
8626 /* If we get here, we must have been looking at a parm for a
8627 more deeply nested template. Make a new version of this
8628 template parameter, but with a lower level. */
8629 switch (TREE_CODE (t
))
8631 case TEMPLATE_TYPE_PARM
:
8632 case TEMPLATE_TEMPLATE_PARM
:
8633 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8634 if (cp_type_quals (t
))
8636 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
8637 r
= cp_build_qualified_type_real
8638 (r
, cp_type_quals (t
),
8639 complain
| (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
8640 ? tf_ignore_bad_quals
: 0));
8645 TEMPLATE_TYPE_PARM_INDEX (r
)
8646 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
8648 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
8649 TYPE_MAIN_VARIANT (r
) = r
;
8650 TYPE_POINTER_TO (r
) = NULL_TREE
;
8651 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
8653 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
8654 /* We have reduced the level of the template
8655 template parameter, but not the levels of its
8656 template parameters, so canonical_type_parameter
8657 will not be able to find the canonical template
8658 template parameter for this level. Thus, we
8659 require structural equality checking to compare
8660 TEMPLATE_TEMPLATE_PARMs. */
8661 SET_TYPE_STRUCTURAL_EQUALITY (r
);
8662 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
8663 SET_TYPE_STRUCTURAL_EQUALITY (r
);
8665 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
8667 if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
8669 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
8671 if (argvec
== error_mark_node
)
8672 return error_mark_node
;
8674 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
8675 = tree_cons (TYPE_TI_TEMPLATE (t
), argvec
, NULL_TREE
);
8680 case TEMPLATE_PARM_INDEX
:
8681 r
= reduce_template_parm_level (t
, type
, levels
);
8693 tree purpose
, value
, chain
;
8695 if (t
== void_list_node
)
8698 purpose
= TREE_PURPOSE (t
);
8701 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
8702 if (purpose
== error_mark_node
)
8703 return error_mark_node
;
8705 value
= TREE_VALUE (t
);
8708 value
= tsubst (value
, args
, complain
, in_decl
);
8709 if (value
== error_mark_node
)
8710 return error_mark_node
;
8712 chain
= TREE_CHAIN (t
);
8713 if (chain
&& chain
!= void_type_node
)
8715 chain
= tsubst (chain
, args
, complain
, in_decl
);
8716 if (chain
== error_mark_node
)
8717 return error_mark_node
;
8719 if (purpose
== TREE_PURPOSE (t
)
8720 && value
== TREE_VALUE (t
)
8721 && chain
== TREE_CHAIN (t
))
8723 return hash_tree_cons (purpose
, value
, chain
);
8727 /* We should never be tsubsting a binfo. */
8731 /* A vector of template arguments. */
8733 return tsubst_template_args (t
, args
, complain
, in_decl
);
8736 case REFERENCE_TYPE
:
8738 enum tree_code code
;
8740 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
8743 code
= TREE_CODE (t
);
8748 Type deduction may fail for any of the following
8751 -- Attempting to create a pointer to reference type.
8752 -- Attempting to create a reference to a reference type or
8753 a reference to void.
8755 Core issue 106 says that creating a reference to a reference
8756 during instantiation is no longer a cause for failure. We
8757 only enforce this check in strict C++98 mode. */
8758 if ((TREE_CODE (type
) == REFERENCE_TYPE
8759 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
8760 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
8762 static location_t last_loc
;
8764 /* We keep track of the last time we issued this error
8765 message to avoid spewing a ton of messages during a
8766 single bad template instantiation. */
8767 if (complain
& tf_error
8768 #ifdef USE_MAPPED_LOCATION
8769 && last_loc
!= input_location
8771 && (last_loc
.line
!= input_line
8772 || last_loc
.file
!= input_filename
)
8776 if (TREE_CODE (type
) == VOID_TYPE
)
8777 error ("forming reference to void");
8779 error ("forming %s to reference type %qT",
8780 (code
== POINTER_TYPE
) ? "pointer" : "reference",
8782 last_loc
= input_location
;
8785 return error_mark_node
;
8787 else if (code
== POINTER_TYPE
)
8789 r
= build_pointer_type (type
);
8790 if (TREE_CODE (type
) == METHOD_TYPE
)
8791 r
= build_ptrmemfunc_type (r
);
8793 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
8794 /* In C++0x, during template argument substitution, when there is an
8795 attempt to create a reference to a reference type, reference
8796 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
8798 "If a template-argument for a template-parameter T names a type
8799 that is a reference to a type A, an attempt to create the type
8800 'lvalue reference to cv T' creates the type 'lvalue reference to
8801 A,' while an attempt to create the type type rvalue reference to
8802 cv T' creates the type T"
8804 r
= cp_build_reference_type
8806 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
8808 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
8809 r
= cp_build_qualified_type_real (r
, TYPE_QUALS (t
), complain
);
8811 if (r
!= error_mark_node
)
8812 /* Will this ever be needed for TYPE_..._TO values? */
8819 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
8820 if (r
== error_mark_node
|| !IS_AGGR_TYPE (r
))
8824 Type deduction may fail for any of the following
8827 -- Attempting to create "pointer to member of T" when T
8828 is not a class type. */
8829 if (complain
& tf_error
)
8830 error ("creating pointer to member of non-class type %qT", r
);
8831 return error_mark_node
;
8833 if (TREE_CODE (type
) == REFERENCE_TYPE
)
8835 if (complain
& tf_error
)
8836 error ("creating pointer to member reference type %qT", type
);
8837 return error_mark_node
;
8839 if (TREE_CODE (type
) == VOID_TYPE
)
8841 if (complain
& tf_error
)
8842 error ("creating pointer to member of type void");
8843 return error_mark_node
;
8845 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
8846 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8848 /* The type of the implicit object parameter gets its
8849 cv-qualifiers from the FUNCTION_TYPE. */
8851 tree this_type
= cp_build_qualified_type (TYPE_MAIN_VARIANT (r
),
8852 cp_type_quals (type
));
8854 method_type
= build_method_type_directly (this_type
,
8856 TYPE_ARG_TYPES (type
));
8857 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
8858 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
8862 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
8871 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
8872 if (fntype
== error_mark_node
)
8873 return error_mark_node
;
8875 /* Substitute the exception specification. */
8876 specs
= tsubst_exception_specification (t
, args
, complain
,
8878 if (specs
== error_mark_node
)
8879 return error_mark_node
;
8881 fntype
= build_exception_variant (fntype
, specs
);
8886 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
8887 if (domain
== error_mark_node
)
8888 return error_mark_node
;
8890 /* As an optimization, we avoid regenerating the array type if
8891 it will obviously be the same as T. */
8892 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
8895 /* These checks should match the ones in grokdeclarator.
8899 The deduction may fail for any of the following reasons:
8901 -- Attempting to create an array with an element type that
8902 is void, a function type, or a reference type, or [DR337]
8903 an abstract class type. */
8904 if (TREE_CODE (type
) == VOID_TYPE
8905 || TREE_CODE (type
) == FUNCTION_TYPE
8906 || TREE_CODE (type
) == REFERENCE_TYPE
)
8908 if (complain
& tf_error
)
8909 error ("creating array of %qT", type
);
8910 return error_mark_node
;
8912 if (CLASS_TYPE_P (type
) && CLASSTYPE_PURE_VIRTUALS (type
))
8914 if (complain
& tf_error
)
8915 error ("creating array of %qT, which is an abstract class type",
8917 return error_mark_node
;
8920 r
= build_cplus_array_type (type
, domain
);
8927 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
8928 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
8930 if (e1
== error_mark_node
|| e2
== error_mark_node
)
8931 return error_mark_node
;
8933 return fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), e1
, e2
);
8939 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
8940 if (e
== error_mark_node
)
8941 return error_mark_node
;
8943 return fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), e
);
8948 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
8949 in_decl
, /*entering_scope=*/1);
8950 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
8953 if (ctx
== error_mark_node
|| f
== error_mark_node
)
8954 return error_mark_node
;
8956 if (!IS_AGGR_TYPE (ctx
))
8958 if (complain
& tf_error
)
8959 error ("%qT is not a class, struct, or union type", ctx
);
8960 return error_mark_node
;
8962 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
8964 /* Normally, make_typename_type does not require that the CTX
8965 have complete type in order to allow things like:
8967 template <class T> struct S { typename S<T>::X Y; };
8969 But, such constructs have already been resolved by this
8970 point, so here CTX really should have complete type, unless
8971 it's a partial instantiation. */
8972 ctx
= complete_type (ctx
);
8973 if (!COMPLETE_TYPE_P (ctx
))
8975 if (complain
& tf_error
)
8976 cxx_incomplete_type_error (NULL_TREE
, ctx
);
8977 return error_mark_node
;
8981 f
= make_typename_type (ctx
, f
, typename_type
,
8982 (complain
& tf_error
) | tf_keep_type_decl
);
8983 if (f
== error_mark_node
)
8985 if (TREE_CODE (f
) == TYPE_DECL
)
8987 complain
|= tf_ignore_bad_quals
;
8991 if (TREE_CODE (f
) != TYPENAME_TYPE
)
8993 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
8994 error ("%qT resolves to %qT, which is not an enumeration type",
8996 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
8997 error ("%qT resolves to %qT, which is is not a class type",
9001 return cp_build_qualified_type_real
9002 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
9005 case UNBOUND_CLASS_TEMPLATE
:
9007 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
9008 in_decl
, /*entering_scope=*/1);
9009 tree name
= TYPE_IDENTIFIER (t
);
9010 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
9012 if (ctx
== error_mark_node
|| name
== error_mark_node
)
9013 return error_mark_node
;
9016 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
9017 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
9027 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9028 tree e2
= tsubst_expr (TREE_OPERAND (t
, 1), args
, complain
, in_decl
,
9029 /*integral_constant_expression_p=*/false);
9030 if (e1
== error_mark_node
|| e2
== error_mark_node
)
9031 return error_mark_node
;
9033 return build_nt (ARRAY_REF
, e1
, e2
, NULL_TREE
, NULL_TREE
);
9038 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9039 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
9040 if (e1
== error_mark_node
|| e2
== error_mark_node
)
9041 return error_mark_node
;
9043 return build_qualified_name (/*type=*/NULL_TREE
,
9044 e1
, e2
, QUALIFIED_NAME_IS_TEMPLATE (t
));
9051 type
= finish_typeof (tsubst_expr
9052 (TYPEOF_TYPE_EXPR (t
), args
,
9054 /*integral_constant_expression_p=*/false));
9055 return cp_build_qualified_type_real (type
,
9057 | cp_type_quals (type
),
9066 finish_decltype_type (tsubst_expr
9067 (DECLTYPE_TYPE_EXPR (t
), args
,
9069 /*integral_constant_expression_p=*/false),
9070 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
));
9071 return cp_build_qualified_type_real (type
,
9073 | cp_type_quals (type
),
9077 case TYPE_ARGUMENT_PACK
:
9078 case NONTYPE_ARGUMENT_PACK
:
9080 tree r
= make_node (TREE_CODE (t
));
9082 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
9086 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
9088 /* For template nontype argument packs, also substitute into
9090 if (TREE_CODE (t
) == NONTYPE_ARGUMENT_PACK
)
9091 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
9098 sorry ("use of %qs in template",
9099 tree_code_name
[(int) TREE_CODE (t
)]);
9100 return error_mark_node
;
9104 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9105 type of the expression on the left-hand side of the "." or "->"
9109 tsubst_baselink (tree baselink
, tree object_type
,
9110 tree args
, tsubst_flags_t complain
, tree in_decl
)
9113 tree qualifying_scope
;
9116 tree template_args
= 0;
9117 bool template_id_p
= false;
9119 /* A baselink indicates a function from a base class. Both the
9120 BASELINK_ACCESS_BINFO and the base class referenced may
9121 indicate bases of the template class, rather than the
9122 instantiated class. In addition, lookups that were not
9123 ambiguous before may be ambiguous now. Therefore, we perform
9124 the lookup again. */
9125 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
9126 qualifying_scope
= tsubst (qualifying_scope
, args
,
9128 fns
= BASELINK_FUNCTIONS (baselink
);
9129 optype
= BASELINK_OPTYPE (baselink
);
9130 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
9132 template_id_p
= true;
9133 template_args
= TREE_OPERAND (fns
, 1);
9134 fns
= TREE_OPERAND (fns
, 0);
9136 template_args
= tsubst_template_args (template_args
, args
,
9139 name
= DECL_NAME (get_first_fn (fns
));
9140 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
9142 /* If lookup found a single function, mark it as used at this
9143 point. (If it lookup found multiple functions the one selected
9144 later by overload resolution will be marked as used at that
9146 if (BASELINK_P (baselink
))
9147 fns
= BASELINK_FUNCTIONS (baselink
);
9148 if (!template_id_p
&& !really_overloaded_fn (fns
))
9149 mark_used (OVL_CURRENT (fns
));
9151 /* Add back the template arguments, if present. */
9152 if (BASELINK_P (baselink
) && template_id_p
)
9153 BASELINK_FUNCTIONS (baselink
)
9154 = build_nt (TEMPLATE_ID_EXPR
,
9155 BASELINK_FUNCTIONS (baselink
),
9157 /* Update the conversion operator type. */
9158 BASELINK_OPTYPE (baselink
)
9159 = tsubst (optype
, args
, complain
, in_decl
);
9162 object_type
= current_class_type
;
9163 return adjust_result_of_qualified_name_lookup (baselink
,
9168 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9169 true if the qualified-id will be a postfix-expression in-and-of
9170 itself; false if more of the postfix-expression follows the
9171 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9175 tsubst_qualified_id (tree qualified_id
, tree args
,
9176 tsubst_flags_t complain
, tree in_decl
,
9177 bool done
, bool address_p
)
9185 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
9187 /* Figure out what name to look up. */
9188 name
= TREE_OPERAND (qualified_id
, 1);
9189 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
9192 template_args
= TREE_OPERAND (name
, 1);
9194 template_args
= tsubst_template_args (template_args
, args
,
9196 name
= TREE_OPERAND (name
, 0);
9200 is_template
= false;
9201 template_args
= NULL_TREE
;
9204 /* Substitute into the qualifying scope. When there are no ARGS, we
9205 are just trying to simplify a non-dependent expression. In that
9206 case the qualifying scope may be dependent, and, in any case,
9207 substituting will not help. */
9208 scope
= TREE_OPERAND (qualified_id
, 0);
9211 scope
= tsubst (scope
, args
, complain
, in_decl
);
9212 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
9217 if (dependent_type_p (scope
))
9218 return build_qualified_name (/*type=*/NULL_TREE
,
9220 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
9222 if (!BASELINK_P (name
) && !DECL_P (expr
))
9224 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
9225 /* If this were actually a destructor call, it would have been
9226 parsed as such by the parser. */
9227 expr
= error_mark_node
;
9229 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
9230 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
9231 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
9233 if (complain
& tf_error
)
9235 error ("dependent-name %qE is parsed as a non-type, but "
9236 "instantiation yields a type", qualified_id
);
9237 inform ("say %<typename %E%> if a type is meant", qualified_id
);
9239 return error_mark_node
;
9245 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
9247 /* Remember that there was a reference to this entity. */
9251 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
9253 if (complain
& tf_error
)
9254 qualified_name_lookup_error (scope
,
9255 TREE_OPERAND (qualified_id
, 1),
9257 return error_mark_node
;
9261 expr
= lookup_template_function (expr
, template_args
);
9263 if (expr
== error_mark_node
&& complain
& tf_error
)
9264 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
9266 else if (TYPE_P (scope
))
9268 expr
= (adjust_result_of_qualified_name_lookup
9269 (expr
, scope
, current_class_type
));
9270 expr
= (finish_qualified_id_expr
9271 (scope
, expr
, done
, address_p
,
9272 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
9273 /*template_arg_p=*/false));
9276 /* Expressions do not generally have reference type. */
9277 if (TREE_CODE (expr
) != SCOPE_REF
9278 /* However, if we're about to form a pointer-to-member, we just
9279 want the referenced member referenced. */
9280 && TREE_CODE (expr
) != OFFSET_REF
)
9281 expr
= convert_from_reference (expr
);
9286 /* Like tsubst, but deals with expressions. This function just replaces
9287 template parms; to finish processing the resultant expression, use
9291 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9293 enum tree_code code
;
9296 if (t
== NULL_TREE
|| t
== error_mark_node
)
9299 code
= TREE_CODE (t
);
9304 r
= retrieve_local_specialization (t
);
9305 gcc_assert (r
!= NULL
);
9306 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
9307 r
= ARGUMENT_PACK_SELECT_ARG (r
);
9316 if (DECL_TEMPLATE_PARM_P (t
))
9317 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
9318 /* There is no need to substitute into namespace-scope
9320 if (DECL_NAMESPACE_SCOPE_P (t
))
9322 /* If ARGS is NULL, then T is known to be non-dependent. */
9323 if (args
== NULL_TREE
)
9324 return integral_constant_value (t
);
9326 /* Unfortunately, we cannot just call lookup_name here.
9329 template <int I> int f() {
9331 struct S { void g() { E e = a; } };
9334 When we instantiate f<7>::S::g(), say, lookup_name is not
9335 clever enough to find f<7>::a. */
9337 = tsubst_aggr_type (TREE_TYPE (t
), args
, complain
, in_decl
,
9338 /*entering_scope=*/0);
9340 for (v
= TYPE_VALUES (enum_type
);
9343 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
9344 return TREE_VALUE (v
);
9346 /* We didn't find the name. That should never happen; if
9347 name-lookup found it during preliminary parsing, we
9348 should find it again here during instantiation. */
9354 if (DECL_CONTEXT (t
))
9358 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
9359 /*entering_scope=*/1);
9360 if (ctx
!= DECL_CONTEXT (t
))
9362 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
9365 if (complain
& tf_error
)
9366 error ("using invalid field %qD", t
);
9367 return error_mark_node
;
9377 if ((DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9378 || local_variable_p (t
))
9379 t
= tsubst (t
, args
, complain
, in_decl
);
9384 return tsubst_baselink (t
, current_class_type
, args
, complain
, in_decl
);
9387 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9388 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
9389 args
, complain
, in_decl
);
9390 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
9391 return tsubst (t
, args
, complain
, in_decl
);
9392 else if (DECL_CLASS_SCOPE_P (t
)
9393 && uses_template_parms (DECL_CONTEXT (t
)))
9395 /* Template template argument like the following example need
9398 template <template <class> class TT> struct C {};
9399 template <class T> struct D {
9400 template <class U> struct E {};
9405 We are processing the template argument `E' in #1 for
9406 the template instantiation #2. Originally, `E' is a
9407 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9408 have to substitute this with one having context `D<int>'. */
9410 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
9411 return lookup_field (context
, DECL_NAME(t
), 0, false);
9414 /* Ordinary template template argument. */
9418 case REINTERPRET_CAST_EXPR
:
9419 case CONST_CAST_EXPR
:
9420 case STATIC_CAST_EXPR
:
9421 case DYNAMIC_CAST_EXPR
:
9424 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
9425 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
9428 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
9430 /* We only want to compute the number of arguments. */
9431 tree expanded
= tsubst_pack_expansion (TREE_OPERAND (t
, 0), args
,
9433 return build_int_cst (size_type_node
, TREE_VEC_LENGTH (expanded
));
9439 case TRUTH_NOT_EXPR
:
9442 case UNARY_PLUS_EXPR
: /* Unary + */
9450 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
9451 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
9458 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9459 name
= TREE_OPERAND (t
, 1);
9460 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
9462 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9464 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
9466 else if (TREE_CODE (name
) == SCOPE_REF
9467 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
9469 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9471 name
= TREE_OPERAND (name
, 1);
9472 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9474 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
9475 name
= build_qualified_name (/*type=*/NULL_TREE
,
9477 /*template_p=*/false);
9479 else if (TREE_CODE (name
) == BASELINK
)
9480 name
= tsubst_baselink (name
,
9481 non_reference (TREE_TYPE (object
)),
9485 name
= tsubst_copy (name
, args
, complain
, in_decl
);
9486 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
9492 case TRUNC_DIV_EXPR
:
9494 case FLOOR_DIV_EXPR
:
9495 case ROUND_DIV_EXPR
:
9496 case EXACT_DIV_EXPR
:
9500 case TRUNC_MOD_EXPR
:
9501 case FLOOR_MOD_EXPR
:
9502 case TRUTH_ANDIF_EXPR
:
9503 case TRUTH_ORIF_EXPR
:
9504 case TRUTH_AND_EXPR
:
9521 case PREDECREMENT_EXPR
:
9522 case PREINCREMENT_EXPR
:
9523 case POSTDECREMENT_EXPR
:
9524 case POSTINCREMENT_EXPR
:
9526 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
9527 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
9530 return build_qualified_name (/*type=*/NULL_TREE
,
9531 tsubst_copy (TREE_OPERAND (t
, 0),
9532 args
, complain
, in_decl
),
9533 tsubst_copy (TREE_OPERAND (t
, 1),
9534 args
, complain
, in_decl
),
9535 QUALIFIED_NAME_IS_TEMPLATE (t
));
9540 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
9541 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
9542 NULL_TREE
, NULL_TREE
);
9546 int n
= VL_EXP_OPERAND_LENGTH (t
);
9547 tree result
= build_vl_exp (CALL_EXPR
, n
);
9549 for (i
= 0; i
< n
; i
++)
9550 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
9557 case PSEUDO_DTOR_EXPR
:
9560 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
9561 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
9562 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
9563 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
9570 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
9571 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
9572 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
9573 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
9580 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
9581 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
9582 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
9583 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
9587 case TEMPLATE_ID_EXPR
:
9589 /* Substituted template arguments */
9590 tree fn
= TREE_OPERAND (t
, 0);
9591 tree targs
= TREE_OPERAND (t
, 1);
9593 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
9595 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
9597 return lookup_template_function (fn
, targs
);
9602 tree purpose
, value
, chain
;
9604 if (t
== void_list_node
)
9607 purpose
= TREE_PURPOSE (t
);
9609 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
9610 value
= TREE_VALUE (t
);
9612 value
= tsubst_copy (value
, args
, complain
, in_decl
);
9613 chain
= TREE_CHAIN (t
);
9614 if (chain
&& chain
!= void_type_node
)
9615 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
9616 if (purpose
== TREE_PURPOSE (t
)
9617 && value
== TREE_VALUE (t
)
9618 && chain
== TREE_CHAIN (t
))
9620 return tree_cons (purpose
, value
, chain
);
9627 case TEMPLATE_TYPE_PARM
:
9628 case TEMPLATE_TEMPLATE_PARM
:
9629 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9630 case TEMPLATE_PARM_INDEX
:
9632 case REFERENCE_TYPE
:
9638 case UNBOUND_CLASS_TEMPLATE
:
9642 return tsubst (t
, args
, complain
, in_decl
);
9644 case IDENTIFIER_NODE
:
9645 if (IDENTIFIER_TYPENAME_P (t
))
9647 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
9648 return mangle_conv_op_name_for_type (new_type
);
9654 /* This is handled by tsubst_copy_and_build. */
9658 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
9660 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
9662 case CLEANUP_POINT_EXPR
:
9663 /* We shouldn't have built any of these during initial template
9664 generation. Instead, they should be built during instantiation
9665 in response to the saved STMT_IS_FULL_EXPR_P setting. */
9669 mark_used (TREE_OPERAND (t
, 1));
9672 case EXPR_PACK_EXPANSION
:
9673 error ("invalid use of pack expansion expression");
9674 return error_mark_node
;
9676 case NONTYPE_ARGUMENT_PACK
:
9677 error ("use %<...%> to expand argument pack");
9678 return error_mark_node
;
9685 /* Like tsubst_copy, but specifically for OpenMP clauses. */
9688 tsubst_omp_clauses (tree clauses
, tree args
, tsubst_flags_t complain
,
9691 tree new_clauses
= NULL
, nc
, oc
;
9693 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
9695 nc
= copy_node (oc
);
9696 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
9699 switch (OMP_CLAUSE_CODE (nc
))
9701 case OMP_CLAUSE_PRIVATE
:
9702 case OMP_CLAUSE_SHARED
:
9703 case OMP_CLAUSE_FIRSTPRIVATE
:
9704 case OMP_CLAUSE_LASTPRIVATE
:
9705 case OMP_CLAUSE_REDUCTION
:
9706 case OMP_CLAUSE_COPYIN
:
9707 case OMP_CLAUSE_COPYPRIVATE
:
9709 case OMP_CLAUSE_NUM_THREADS
:
9710 case OMP_CLAUSE_SCHEDULE
:
9711 OMP_CLAUSE_OPERAND (nc
, 0)
9712 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
9713 in_decl
, /*integral_constant_expression_p=*/false);
9715 case OMP_CLAUSE_NOWAIT
:
9716 case OMP_CLAUSE_ORDERED
:
9717 case OMP_CLAUSE_DEFAULT
:
9724 return finish_omp_clauses (nreverse (new_clauses
));
9727 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
9730 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
9733 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
9735 tree purpose
, value
, chain
;
9740 if (TREE_CODE (t
) != TREE_LIST
)
9741 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
9742 /*function_p=*/false,
9743 /*integral_constant_expression_p=*/false);
9745 if (t
== void_list_node
)
9748 purpose
= TREE_PURPOSE (t
);
9750 purpose
= RECUR (purpose
);
9751 value
= TREE_VALUE (t
);
9753 value
= RECUR (value
);
9754 chain
= TREE_CHAIN (t
);
9755 if (chain
&& chain
!= void_type_node
)
9756 chain
= RECUR (chain
);
9757 return tree_cons (purpose
, value
, chain
);
9761 /* Like tsubst_copy for expressions, etc. but also does semantic
9765 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
9766 bool integral_constant_expression_p
)
9768 #define RECUR(NODE) \
9769 tsubst_expr ((NODE), args, complain, in_decl, \
9770 integral_constant_expression_p)
9774 if (t
== NULL_TREE
|| t
== error_mark_node
)
9777 if (EXPR_HAS_LOCATION (t
))
9778 input_location
= EXPR_LOCATION (t
);
9779 if (STATEMENT_CODE_P (TREE_CODE (t
)))
9780 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
9782 switch (TREE_CODE (t
))
9784 case STATEMENT_LIST
:
9786 tree_stmt_iterator i
;
9787 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
9788 RECUR (tsi_stmt (i
));
9792 case CTOR_INITIALIZER
:
9793 finish_mem_initializers (tsubst_initializer_list
9794 (TREE_OPERAND (t
, 0), args
));
9798 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
9802 tmp
= RECUR (EXPR_STMT_EXPR (t
));
9803 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
9804 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
9806 finish_expr_stmt (tmp
);
9810 do_using_directive (RECUR (USING_STMT_NAMESPACE (t
)));
9818 decl
= DECL_EXPR_DECL (t
);
9819 if (TREE_CODE (decl
) == LABEL_DECL
)
9820 finish_label_decl (DECL_NAME (decl
));
9821 else if (TREE_CODE (decl
) == USING_DECL
)
9823 tree scope
= USING_DECL_SCOPE (decl
);
9824 tree name
= DECL_NAME (decl
);
9827 scope
= RECUR (scope
);
9828 decl
= lookup_qualified_name (scope
, name
,
9829 /*is_type_p=*/false,
9830 /*complain=*/false);
9831 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
9832 qualified_name_lookup_error (scope
, name
, decl
);
9834 do_local_using_decl (decl
, scope
, name
);
9838 init
= DECL_INITIAL (decl
);
9839 decl
= tsubst (decl
, args
, complain
, in_decl
);
9840 if (decl
!= error_mark_node
)
9842 /* By marking the declaration as instantiated, we avoid
9843 trying to instantiate it. Since instantiate_decl can't
9844 handle local variables, and since we've already done
9845 all that needs to be done, that's the right thing to
9847 if (TREE_CODE (decl
) == VAR_DECL
)
9848 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
9849 if (TREE_CODE (decl
) == VAR_DECL
9850 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
9851 /* Anonymous aggregates are a special case. */
9852 finish_anon_union (decl
);
9855 maybe_push_decl (decl
);
9856 if (TREE_CODE (decl
) == VAR_DECL
9857 && DECL_PRETTY_FUNCTION_P (decl
))
9859 /* For __PRETTY_FUNCTION__ we have to adjust the
9861 const char *const name
9862 = cxx_printable_name (current_function_decl
, 2);
9863 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
9866 init
= RECUR (init
);
9867 finish_decl (decl
, init
, NULL_TREE
);
9872 /* A DECL_EXPR can also be used as an expression, in the condition
9873 clause of an if/for/while construct. */
9878 stmt
= begin_for_stmt ();
9879 RECUR (FOR_INIT_STMT (t
));
9880 finish_for_init_stmt (stmt
);
9881 tmp
= RECUR (FOR_COND (t
));
9882 finish_for_cond (tmp
, stmt
);
9883 tmp
= RECUR (FOR_EXPR (t
));
9884 finish_for_expr (tmp
, stmt
);
9885 RECUR (FOR_BODY (t
));
9886 finish_for_stmt (stmt
);
9890 stmt
= begin_while_stmt ();
9891 tmp
= RECUR (WHILE_COND (t
));
9892 finish_while_stmt_cond (tmp
, stmt
);
9893 RECUR (WHILE_BODY (t
));
9894 finish_while_stmt (stmt
);
9898 stmt
= begin_do_stmt ();
9899 RECUR (DO_BODY (t
));
9900 finish_do_body (stmt
);
9901 tmp
= RECUR (DO_COND (t
));
9902 finish_do_stmt (tmp
, stmt
);
9906 stmt
= begin_if_stmt ();
9907 tmp
= RECUR (IF_COND (t
));
9908 finish_if_stmt_cond (tmp
, stmt
);
9909 RECUR (THEN_CLAUSE (t
));
9910 finish_then_clause (stmt
);
9912 if (ELSE_CLAUSE (t
))
9914 begin_else_clause (stmt
);
9915 RECUR (ELSE_CLAUSE (t
));
9916 finish_else_clause (stmt
);
9919 finish_if_stmt (stmt
);
9923 if (BIND_EXPR_BODY_BLOCK (t
))
9924 stmt
= begin_function_body ();
9926 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
9927 ? BCS_TRY_BLOCK
: 0);
9929 RECUR (BIND_EXPR_BODY (t
));
9931 if (BIND_EXPR_BODY_BLOCK (t
))
9932 finish_function_body (stmt
);
9934 finish_compound_stmt (stmt
);
9938 finish_break_stmt ();
9942 finish_continue_stmt ();
9946 stmt
= begin_switch_stmt ();
9947 tmp
= RECUR (SWITCH_STMT_COND (t
));
9948 finish_switch_cond (tmp
, stmt
);
9949 RECUR (SWITCH_STMT_BODY (t
));
9950 finish_switch_stmt (stmt
);
9953 case CASE_LABEL_EXPR
:
9954 finish_case_label (RECUR (CASE_LOW (t
)),
9955 RECUR (CASE_HIGH (t
)));
9959 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t
)));
9963 tmp
= GOTO_DESTINATION (t
);
9964 if (TREE_CODE (tmp
) != LABEL_DECL
)
9965 /* Computed goto's must be tsubst'd into. On the other hand,
9966 non-computed gotos must not be; the identifier in question
9967 will have no binding. */
9970 tmp
= DECL_NAME (tmp
);
9971 finish_goto_stmt (tmp
);
9975 tmp
= finish_asm_stmt
9976 (ASM_VOLATILE_P (t
),
9977 RECUR (ASM_STRING (t
)),
9978 tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
9979 tsubst_copy_asm_operands (ASM_INPUTS (t
), args
, complain
, in_decl
),
9980 tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
, complain
, in_decl
));
9982 tree asm_expr
= tmp
;
9983 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
9984 asm_expr
= TREE_OPERAND (asm_expr
, 0);
9985 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
9992 stmt
= begin_try_block ();
9993 RECUR (TRY_STMTS (t
));
9994 finish_cleanup_try_block (stmt
);
9995 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
9999 tree compound_stmt
= NULL_TREE
;
10001 if (FN_TRY_BLOCK_P (t
))
10002 stmt
= begin_function_try_block (&compound_stmt
);
10004 stmt
= begin_try_block ();
10006 RECUR (TRY_STMTS (t
));
10008 if (FN_TRY_BLOCK_P (t
))
10009 finish_function_try_block (stmt
);
10011 finish_try_block (stmt
);
10013 RECUR (TRY_HANDLERS (t
));
10014 if (FN_TRY_BLOCK_P (t
))
10015 finish_function_handler_sequence (stmt
, compound_stmt
);
10017 finish_handler_sequence (stmt
);
10023 tree decl
= HANDLER_PARMS (t
);
10027 decl
= tsubst (decl
, args
, complain
, in_decl
);
10028 /* Prevent instantiate_decl from trying to instantiate
10029 this variable. We've already done all that needs to be
10031 if (decl
!= error_mark_node
)
10032 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
10034 stmt
= begin_handler ();
10035 finish_handler_parms (decl
, stmt
);
10036 RECUR (HANDLER_BODY (t
));
10037 finish_handler (stmt
);
10042 tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
10045 case STATIC_ASSERT
:
10048 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
10051 /*integral_constant_expression_p=*/true);
10052 finish_static_assert (condition
,
10053 STATIC_ASSERT_MESSAGE (t
),
10054 STATIC_ASSERT_SOURCE_LOCATION (t
),
10055 /*member_p=*/false);
10060 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
),
10061 args
, complain
, in_decl
);
10062 stmt
= begin_omp_parallel ();
10063 RECUR (OMP_PARALLEL_BODY (t
));
10064 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
10065 = OMP_PARALLEL_COMBINED (t
);
10070 tree clauses
, decl
, init
, cond
, incr
, body
, pre_body
;
10072 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
),
10073 args
, complain
, in_decl
);
10074 init
= OMP_FOR_INIT (t
);
10075 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
10076 decl
= RECUR (TREE_OPERAND (init
, 0));
10077 init
= RECUR (TREE_OPERAND (init
, 1));
10078 cond
= RECUR (OMP_FOR_COND (t
));
10079 incr
= RECUR (OMP_FOR_INCR (t
));
10081 stmt
= begin_omp_structured_block ();
10083 pre_body
= push_stmt_list ();
10084 RECUR (OMP_FOR_PRE_BODY (t
));
10085 pre_body
= pop_stmt_list (pre_body
);
10087 body
= push_stmt_list ();
10088 RECUR (OMP_FOR_BODY (t
));
10089 body
= pop_stmt_list (body
);
10091 t
= finish_omp_for (EXPR_LOCATION (t
), decl
, init
, cond
, incr
, body
,
10094 OMP_FOR_CLAUSES (t
) = clauses
;
10096 add_stmt (finish_omp_structured_block (stmt
));
10102 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), args
, complain
, in_decl
);
10103 stmt
= push_stmt_list ();
10104 RECUR (OMP_BODY (t
));
10105 stmt
= pop_stmt_list (stmt
);
10108 OMP_BODY (t
) = stmt
;
10109 OMP_CLAUSES (t
) = tmp
;
10117 stmt
= push_stmt_list ();
10118 RECUR (OMP_BODY (t
));
10119 stmt
= pop_stmt_list (stmt
);
10122 OMP_BODY (t
) = stmt
;
10127 if (OMP_ATOMIC_DEPENDENT_P (t
))
10129 tree op1
= TREE_OPERAND (t
, 1);
10130 tree lhs
= RECUR (TREE_OPERAND (op1
, 0));
10131 tree rhs
= RECUR (TREE_OPERAND (op1
, 1));
10132 finish_omp_atomic (TREE_CODE (op1
), lhs
, rhs
);
10136 case EXPR_PACK_EXPANSION
:
10137 error ("invalid use of pack expansion expression");
10138 return error_mark_node
;
10140 case NONTYPE_ARGUMENT_PACK
:
10141 error ("use %<...%> to expand argument pack");
10142 return error_mark_node
;
10145 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
10147 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
10148 /*function_p=*/false,
10149 integral_constant_expression_p
);
10156 /* T is a postfix-expression that is not being used in a function
10157 call. Return the substituted version of T. */
10160 tsubst_non_call_postfix_expression (tree t
, tree args
,
10161 tsubst_flags_t complain
,
10164 if (TREE_CODE (t
) == SCOPE_REF
)
10165 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
10166 /*done=*/false, /*address_p=*/false);
10168 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
10169 /*function_p=*/false,
10170 /*integral_constant_expression_p=*/false);
10175 /* Like tsubst but deals with expressions and performs semantic
10176 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10179 tsubst_copy_and_build (tree t
,
10181 tsubst_flags_t complain
,
10184 bool integral_constant_expression_p
)
10186 #define RECUR(NODE) \
10187 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10188 /*function_p=*/false, \
10189 integral_constant_expression_p)
10193 if (t
== NULL_TREE
|| t
== error_mark_node
)
10196 switch (TREE_CODE (t
))
10200 /* Fall through. */
10201 case IDENTIFIER_NODE
:
10205 bool non_integral_constant_expression_p
;
10206 const char *error_msg
;
10208 if (IDENTIFIER_TYPENAME_P (t
))
10210 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10211 t
= mangle_conv_op_name_for_type (new_type
);
10214 /* Look up the name. */
10215 decl
= lookup_name (t
);
10217 /* By convention, expressions use ERROR_MARK_NODE to indicate
10218 failure, not NULL_TREE. */
10219 if (decl
== NULL_TREE
)
10220 decl
= error_mark_node
;
10222 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
10224 integral_constant_expression_p
,
10225 /*allow_non_integral_constant_expression_p=*/false,
10226 &non_integral_constant_expression_p
,
10227 /*template_p=*/false,
10229 /*address_p=*/false,
10230 /*template_arg_p=*/false,
10234 if (!function_p
&& TREE_CODE (decl
) == IDENTIFIER_NODE
)
10235 decl
= unqualified_name_lookup_error (decl
);
10239 case TEMPLATE_ID_EXPR
:
10242 tree
template = RECUR (TREE_OPERAND (t
, 0));
10243 tree targs
= TREE_OPERAND (t
, 1);
10246 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
10248 if (TREE_CODE (template) == COMPONENT_REF
)
10250 object
= TREE_OPERAND (template, 0);
10251 template = TREE_OPERAND (template, 1);
10254 object
= NULL_TREE
;
10255 template = lookup_template_function (template, targs
);
10258 return build3 (COMPONENT_REF
, TREE_TYPE (template),
10259 object
, template, NULL_TREE
);
10261 return baselink_for_fns (template);
10266 tree r
= RECUR (TREE_OPERAND (t
, 0));
10268 if (REFERENCE_REF_P (t
))
10270 /* A type conversion to reference type will be enclosed in
10271 such an indirect ref, but the substitution of the cast
10272 will have also added such an indirect ref. */
10273 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
10274 r
= convert_from_reference (r
);
10277 r
= build_x_indirect_ref (r
, "unary *");
10283 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
10284 RECUR (TREE_OPERAND (t
, 0)));
10287 case REINTERPRET_CAST_EXPR
:
10288 case CONST_CAST_EXPR
:
10289 case DYNAMIC_CAST_EXPR
:
10290 case STATIC_CAST_EXPR
:
10295 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10296 if (integral_constant_expression_p
10297 && !cast_valid_in_integral_constant_expression_p (type
))
10299 error ("a cast to a type other than an integral or "
10300 "enumeration type cannot appear in a constant-expression");
10301 return error_mark_node
;
10304 op
= RECUR (TREE_OPERAND (t
, 0));
10306 switch (TREE_CODE (t
))
10309 return build_functional_cast (type
, op
);
10310 case REINTERPRET_CAST_EXPR
:
10311 return build_reinterpret_cast (type
, op
);
10312 case CONST_CAST_EXPR
:
10313 return build_const_cast (type
, op
);
10314 case DYNAMIC_CAST_EXPR
:
10315 return build_dynamic_cast (type
, op
);
10316 case STATIC_CAST_EXPR
:
10317 return build_static_cast (type
, op
);
10319 gcc_unreachable ();
10323 case POSTDECREMENT_EXPR
:
10324 case POSTINCREMENT_EXPR
:
10325 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10326 args
, complain
, in_decl
);
10327 return build_x_unary_op (TREE_CODE (t
), op1
);
10329 case PREDECREMENT_EXPR
:
10330 case PREINCREMENT_EXPR
:
10334 case TRUTH_NOT_EXPR
:
10335 case UNARY_PLUS_EXPR
: /* Unary + */
10336 case REALPART_EXPR
:
10337 case IMAGPART_EXPR
:
10338 return build_x_unary_op (TREE_CODE (t
), RECUR (TREE_OPERAND (t
, 0)));
10341 op1
= TREE_OPERAND (t
, 0);
10342 if (TREE_CODE (op1
) == SCOPE_REF
)
10343 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
10344 /*done=*/true, /*address_p=*/true);
10346 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
10348 if (TREE_CODE (op1
) == LABEL_DECL
)
10349 return finish_label_address_expr (DECL_NAME (op1
));
10350 return build_x_unary_op (ADDR_EXPR
, op1
);
10355 case TRUNC_DIV_EXPR
:
10356 case CEIL_DIV_EXPR
:
10357 case FLOOR_DIV_EXPR
:
10358 case ROUND_DIV_EXPR
:
10359 case EXACT_DIV_EXPR
:
10363 case TRUNC_MOD_EXPR
:
10364 case FLOOR_MOD_EXPR
:
10365 case TRUTH_ANDIF_EXPR
:
10366 case TRUTH_ORIF_EXPR
:
10367 case TRUTH_AND_EXPR
:
10368 case TRUTH_OR_EXPR
:
10383 return build_x_binary_op
10385 RECUR (TREE_OPERAND (t
, 0)),
10386 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
10388 : TREE_CODE (TREE_OPERAND (t
, 0))),
10389 RECUR (TREE_OPERAND (t
, 1)),
10390 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
10392 : TREE_CODE (TREE_OPERAND (t
, 1))),
10393 /*overloaded_p=*/NULL
);
10396 return tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
10397 /*address_p=*/false);
10399 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10400 args
, complain
, in_decl
);
10401 return build_x_binary_op (ARRAY_REF
, op1
,
10402 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
10404 : TREE_CODE (TREE_OPERAND (t
, 0))),
10405 RECUR (TREE_OPERAND (t
, 1)),
10406 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
10408 : TREE_CODE (TREE_OPERAND (t
, 1))),
10409 /*overloaded_p=*/NULL
);
10412 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
10414 /* We only want to compute the number of arguments. */
10415 tree expanded
= tsubst_pack_expansion (TREE_OPERAND (t
, 0), args
,
10416 complain
, in_decl
);
10417 return build_int_cst (size_type_node
, TREE_VEC_LENGTH (expanded
));
10422 op1
= TREE_OPERAND (t
, 0);
10425 /* When there are no ARGS, we are trying to evaluate a
10426 non-dependent expression from the parser. Trying to do
10427 the substitutions may not work. */
10429 op1
= TREE_TYPE (op1
);
10434 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
10435 /*function_p=*/false,
10436 /*integral_constant_expression_p=*/false);
10440 return cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
), true);
10442 return cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
));
10446 tree r
= build_x_modify_expr
10447 (RECUR (TREE_OPERAND (t
, 0)),
10448 TREE_CODE (TREE_OPERAND (t
, 1)),
10449 RECUR (TREE_OPERAND (t
, 2)));
10450 /* TREE_NO_WARNING must be set if either the expression was
10451 parenthesized or it uses an operator such as >>= rather
10452 than plain assignment. In the former case, it was already
10453 set and must be copied. In the latter case,
10454 build_x_modify_expr sets it and it must not be reset
10456 if (TREE_NO_WARNING (t
))
10457 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
10462 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10463 args
, complain
, in_decl
);
10464 /* Remember that there was a reference to this entity. */
10467 return build_x_arrow (op1
);
10471 (RECUR (TREE_OPERAND (t
, 0)),
10472 RECUR (TREE_OPERAND (t
, 1)),
10473 RECUR (TREE_OPERAND (t
, 2)),
10474 RECUR (TREE_OPERAND (t
, 3)),
10475 NEW_EXPR_USE_GLOBAL (t
));
10478 return delete_sanity
10479 (RECUR (TREE_OPERAND (t
, 0)),
10480 RECUR (TREE_OPERAND (t
, 1)),
10481 DELETE_EXPR_USE_VEC (t
),
10482 DELETE_EXPR_USE_GLOBAL (t
));
10484 case COMPOUND_EXPR
:
10485 return build_x_compound_expr (RECUR (TREE_OPERAND (t
, 0)),
10486 RECUR (TREE_OPERAND (t
, 1)));
10495 function
= CALL_EXPR_FN (t
);
10496 /* When we parsed the expression, we determined whether or
10497 not Koenig lookup should be performed. */
10498 koenig_p
= KOENIG_LOOKUP_P (t
);
10499 if (TREE_CODE (function
) == SCOPE_REF
)
10501 qualified_p
= true;
10502 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
10504 /*address_p=*/false);
10508 if (TREE_CODE (function
) == COMPONENT_REF
)
10510 tree op
= TREE_OPERAND (function
, 1);
10512 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
10513 || (BASELINK_P (op
)
10514 && BASELINK_QUALIFIED_P (op
)));
10517 qualified_p
= false;
10519 function
= tsubst_copy_and_build (function
, args
, complain
,
10522 integral_constant_expression_p
);
10524 if (BASELINK_P (function
))
10525 qualified_p
= true;
10528 /* FIXME: Rewrite this so as not to construct an arglist. */
10529 call_args
= RECUR (CALL_EXPR_ARGS (t
));
10531 /* We do not perform argument-dependent lookup if normal
10532 lookup finds a non-function, in accordance with the
10533 expected resolution of DR 218. */
10535 && ((is_overloaded_fn (function
)
10536 /* If lookup found a member function, the Koenig lookup is
10537 not appropriate, even if an unqualified-name was used
10538 to denote the function. */
10539 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
10540 || TREE_CODE (function
) == IDENTIFIER_NODE
))
10541 function
= perform_koenig_lookup (function
, call_args
);
10543 if (TREE_CODE (function
) == IDENTIFIER_NODE
)
10545 unqualified_name_lookup_error (function
);
10546 return error_mark_node
;
10549 /* Remember that there was a reference to this entity. */
10550 if (DECL_P (function
))
10551 mark_used (function
);
10553 if (TREE_CODE (function
) == OFFSET_REF
)
10554 return build_offset_ref_call_from_tree (function
, call_args
);
10555 if (TREE_CODE (function
) == COMPONENT_REF
)
10557 if (!BASELINK_P (TREE_OPERAND (function
, 1)))
10558 return finish_call_expr (function
, call_args
,
10559 /*disallow_virtual=*/false,
10560 /*koenig_p=*/false);
10562 return (build_new_method_call
10563 (TREE_OPERAND (function
, 0),
10564 TREE_OPERAND (function
, 1),
10565 call_args
, NULL_TREE
,
10566 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
10569 return finish_call_expr (function
, call_args
,
10570 /*disallow_virtual=*/qualified_p
,
10575 return build_x_conditional_expr
10576 (RECUR (TREE_OPERAND (t
, 0)),
10577 RECUR (TREE_OPERAND (t
, 1)),
10578 RECUR (TREE_OPERAND (t
, 2)));
10580 case PSEUDO_DTOR_EXPR
:
10581 return finish_pseudo_destructor_expr
10582 (RECUR (TREE_OPERAND (t
, 0)),
10583 RECUR (TREE_OPERAND (t
, 1)),
10584 RECUR (TREE_OPERAND (t
, 2)));
10588 tree purpose
, value
, chain
;
10590 if (t
== void_list_node
)
10593 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
10594 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
10596 /* We have pack expansions, so expand those and
10597 create a new list out of it. */
10598 tree purposevec
= NULL_TREE
;
10599 tree valuevec
= NULL_TREE
;
10603 /* Expand the argument expressions. */
10604 if (TREE_PURPOSE (t
))
10605 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
10606 complain
, in_decl
);
10607 if (TREE_VALUE (t
))
10608 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
10609 complain
, in_decl
);
10611 /* Build the rest of the list. */
10612 chain
= TREE_CHAIN (t
);
10613 if (chain
&& chain
!= void_type_node
)
10614 chain
= RECUR (chain
);
10616 /* Determine the number of arguments. */
10617 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
10619 len
= TREE_VEC_LENGTH (purposevec
);
10620 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
10622 else if (TREE_CODE (valuevec
) == TREE_VEC
)
10623 len
= TREE_VEC_LENGTH (valuevec
);
10626 /* Since we only performed a partial substitution into
10627 the argument pack, we only return a single list
10629 if (purposevec
== TREE_PURPOSE (t
)
10630 && valuevec
== TREE_VALUE (t
)
10631 && chain
== TREE_CHAIN (t
))
10634 return tree_cons (purposevec
, valuevec
, chain
);
10637 /* Convert the argument vectors into a TREE_LIST */
10641 /* Grab the Ith values. */
10643 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
10646 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
10649 /* Build the list (backwards). */
10650 chain
= tree_cons (purpose
, value
, chain
);
10656 purpose
= TREE_PURPOSE (t
);
10658 purpose
= RECUR (purpose
);
10659 value
= TREE_VALUE (t
);
10661 value
= RECUR (value
);
10662 chain
= TREE_CHAIN (t
);
10663 if (chain
&& chain
!= void_type_node
)
10664 chain
= RECUR (chain
);
10665 if (purpose
== TREE_PURPOSE (t
)
10666 && value
== TREE_VALUE (t
)
10667 && chain
== TREE_CHAIN (t
))
10669 return tree_cons (purpose
, value
, chain
);
10672 case COMPONENT_REF
:
10678 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10679 args
, complain
, in_decl
);
10680 /* Remember that there was a reference to this entity. */
10681 if (DECL_P (object
))
10682 mark_used (object
);
10683 object_type
= TREE_TYPE (object
);
10685 member
= TREE_OPERAND (t
, 1);
10686 if (BASELINK_P (member
))
10687 member
= tsubst_baselink (member
,
10688 non_reference (TREE_TYPE (object
)),
10689 args
, complain
, in_decl
);
10691 member
= tsubst_copy (member
, args
, complain
, in_decl
);
10692 if (member
== error_mark_node
)
10693 return error_mark_node
;
10695 if (object_type
&& !CLASS_TYPE_P (object_type
))
10697 if (TREE_CODE (member
) == BIT_NOT_EXPR
)
10698 return finish_pseudo_destructor_expr (object
,
10701 else if (TREE_CODE (member
) == SCOPE_REF
10702 && (TREE_CODE (TREE_OPERAND (member
, 1)) == BIT_NOT_EXPR
))
10703 return finish_pseudo_destructor_expr (object
,
10707 else if (TREE_CODE (member
) == SCOPE_REF
10708 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
10713 /* Lookup the template functions now that we know what the
10715 tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
10716 args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
10717 member
= lookup_qualified_name (TREE_OPERAND (member
, 0), tmpl
,
10718 /*is_type_p=*/false,
10719 /*complain=*/false);
10720 if (BASELINK_P (member
))
10722 BASELINK_FUNCTIONS (member
)
10723 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
10725 member
= (adjust_result_of_qualified_name_lookup
10726 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
10731 qualified_name_lookup_error (object_type
, tmpl
, member
);
10732 return error_mark_node
;
10735 else if (TREE_CODE (member
) == SCOPE_REF
10736 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
10737 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
10739 if (complain
& tf_error
)
10741 if (TYPE_P (TREE_OPERAND (member
, 0)))
10742 error ("%qT is not a class or namespace",
10743 TREE_OPERAND (member
, 0));
10745 error ("%qD is not a class or namespace",
10746 TREE_OPERAND (member
, 0));
10748 return error_mark_node
;
10750 else if (TREE_CODE (member
) == FIELD_DECL
)
10751 return finish_non_static_data_member (member
, object
, NULL_TREE
);
10753 return finish_class_member_access_expr (object
, member
,
10754 /*template_p=*/false);
10759 (RECUR (TREE_OPERAND (t
, 0)));
10763 VEC(constructor_elt
,gc
) *n
;
10764 constructor_elt
*ce
;
10765 unsigned HOST_WIDE_INT idx
;
10766 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10767 bool process_index_p
;
10769 bool need_copy_p
= false;
10771 if (type
== error_mark_node
)
10772 return error_mark_node
;
10774 /* digest_init will do the wrong thing if we let it. */
10775 if (type
&& TYPE_PTRMEMFUNC_P (type
))
10778 /* We do not want to process the index of aggregate
10779 initializers as they are identifier nodes which will be
10780 looked up by digest_init. */
10781 process_index_p
= !(type
&& IS_AGGR_TYPE (type
));
10783 n
= VEC_copy (constructor_elt
, gc
, CONSTRUCTOR_ELTS (t
));
10784 newlen
= VEC_length (constructor_elt
, n
);
10785 for (idx
= 0; VEC_iterate (constructor_elt
, n
, idx
, ce
); idx
++)
10787 if (ce
->index
&& process_index_p
)
10788 ce
->index
= RECUR (ce
->index
);
10790 if (PACK_EXPANSION_P (ce
->value
))
10792 /* Substitute into the pack expansion. */
10793 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
10796 if (TREE_VEC_LENGTH (ce
->value
) == 1)
10797 /* Just move the argument into place. */
10798 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
10801 /* Update the length of the final CONSTRUCTOR
10802 arguments vector, and note that we will need to
10804 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
10805 need_copy_p
= true;
10809 ce
->value
= RECUR (ce
->value
);
10814 VEC(constructor_elt
,gc
) *old_n
= n
;
10816 n
= VEC_alloc (constructor_elt
, gc
, newlen
);
10817 for (idx
= 0; VEC_iterate (constructor_elt
, old_n
, idx
, ce
);
10820 if (TREE_CODE (ce
->value
) == TREE_VEC
)
10822 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
10823 for (i
= 0; i
< len
; ++i
)
10824 CONSTRUCTOR_APPEND_ELT (n
, 0,
10825 TREE_VEC_ELT (ce
->value
, i
));
10828 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
10832 if (TREE_HAS_CONSTRUCTOR (t
))
10833 return finish_compound_literal (type
, n
);
10835 return build_constructor (NULL_TREE
, n
);
10840 tree operand_0
= RECUR (TREE_OPERAND (t
, 0));
10841 if (TYPE_P (operand_0
))
10842 return get_typeid (operand_0
);
10843 return build_typeid (operand_0
);
10853 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
10855 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
10856 /* If the original type was a reference, we'll be wrapped in
10857 the appropriate INDIRECT_REF. */
10858 r
= convert_from_reference (r
);
10863 return build_x_va_arg (RECUR (TREE_OPERAND (t
, 0)),
10864 tsubst_copy (TREE_TYPE (t
), args
, complain
,
10867 case OFFSETOF_EXPR
:
10868 return finish_offsetof (RECUR (TREE_OPERAND (t
, 0)));
10872 tree type1
= tsubst_copy (TRAIT_EXPR_TYPE1 (t
), args
,
10873 complain
, in_decl
);
10875 tree type2
= TRAIT_EXPR_TYPE2 (t
);
10877 type2
= tsubst_copy (type2
, args
, complain
, in_decl
);
10879 return finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
);
10884 tree old_stmt_expr
= cur_stmt_expr
;
10885 tree stmt_expr
= begin_stmt_expr ();
10887 cur_stmt_expr
= stmt_expr
;
10888 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
10889 integral_constant_expression_p
);
10890 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
10891 cur_stmt_expr
= old_stmt_expr
;
10897 t
= tsubst_copy (t
, args
, complain
, in_decl
);
10898 /* As in finish_id_expression, we resolve enumeration constants
10899 to their underlying values. */
10900 if (TREE_CODE (t
) == CONST_DECL
)
10902 used_types_insert (TREE_TYPE (t
));
10903 return DECL_INITIAL (t
);
10908 /* Handle Objective-C++ constructs, if appropriate. */
10911 = objcp_tsubst_copy_and_build (t
, args
, complain
,
10912 in_decl
, /*function_p=*/false);
10916 return tsubst_copy (t
, args
, complain
, in_decl
);
10922 /* Verify that the instantiated ARGS are valid. For type arguments,
10923 make sure that the type's linkage is ok. For non-type arguments,
10924 make sure they are constants if they are integral or enumerations.
10925 Emit an error under control of COMPLAIN, and return TRUE on error. */
10928 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
10930 int ix
, len
= DECL_NTPARMS (tmpl
);
10931 bool result
= false;
10933 for (ix
= 0; ix
!= len
; ix
++)
10935 tree t
= TREE_VEC_ELT (args
, ix
);
10939 /* [basic.link]: A name with no linkage (notably, the name
10940 of a class or enumeration declared in a local scope)
10941 shall not be used to declare an entity with linkage.
10942 This implies that names with no linkage cannot be used as
10943 template arguments. */
10944 tree nt
= no_linkage_check (t
, /*relaxed_p=*/false);
10948 /* DR 488 makes use of a type with no linkage cause
10949 type deduction to fail. */
10950 if (complain
& tf_error
)
10952 if (TYPE_ANONYMOUS_P (nt
))
10953 error ("%qT is/uses anonymous type", t
);
10955 error ("template argument for %qD uses local type %qT",
10960 /* In order to avoid all sorts of complications, we do not
10961 allow variably-modified types as template arguments. */
10962 else if (variably_modified_type_p (t
, NULL_TREE
))
10964 if (complain
& tf_error
)
10965 error ("%qT is a variably modified type", t
);
10969 /* A non-type argument of integral or enumerated type must be a
10971 else if (TREE_TYPE (t
)
10972 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
10973 && !TREE_CONSTANT (t
))
10975 if (complain
& tf_error
)
10976 error ("integral expression %qE is not constant", t
);
10980 if (result
&& (complain
& tf_error
))
10981 error (" trying to instantiate %qD", tmpl
);
10985 /* Instantiate the indicated variable or function template TMPL with
10986 the template arguments in TARG_PTR. */
10989 instantiate_template (tree tmpl
, tree targ_ptr
, tsubst_flags_t complain
)
10994 HOST_WIDE_INT saved_processing_template_decl
;
10996 if (tmpl
== error_mark_node
)
10997 return error_mark_node
;
10999 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
11001 /* If this function is a clone, handle it specially. */
11002 if (DECL_CLONED_FUNCTION_P (tmpl
))
11007 spec
= instantiate_template (DECL_CLONED_FUNCTION (tmpl
), targ_ptr
,
11009 if (spec
== error_mark_node
)
11010 return error_mark_node
;
11012 /* Look for the clone. */
11013 FOR_EACH_CLONE (clone
, spec
)
11014 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
11016 /* We should always have found the clone by now. */
11017 gcc_unreachable ();
11021 /* Check to see if we already have this specialization. */
11022 spec
= retrieve_specialization (tmpl
, targ_ptr
,
11023 /*class_specializations_p=*/false);
11024 if (spec
!= NULL_TREE
)
11027 gen_tmpl
= most_general_template (tmpl
);
11028 if (tmpl
!= gen_tmpl
)
11030 /* The TMPL is a partial instantiation. To get a full set of
11031 arguments we must add the arguments used to perform the
11032 partial instantiation. */
11033 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
11036 /* Check to see if we already have this specialization. */
11037 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
,
11038 /*class_specializations_p=*/false);
11039 if (spec
!= NULL_TREE
)
11043 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
11045 return error_mark_node
;
11047 /* We are building a FUNCTION_DECL, during which the access of its
11048 parameters and return types have to be checked. However this
11049 FUNCTION_DECL which is the desired context for access checking
11050 is not built yet. We solve this chicken-and-egg problem by
11051 deferring all checks until we have the FUNCTION_DECL. */
11052 push_deferring_access_checks (dk_deferred
);
11054 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11055 (because, for example, we have encountered a non-dependent
11056 function call in the body of a template function and must now
11057 determine which of several overloaded functions will be called),
11058 within the instantiation itself we are not processing a
11060 saved_processing_template_decl
= processing_template_decl
;
11061 processing_template_decl
= 0;
11062 /* Substitute template parameters to obtain the specialization. */
11063 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
11064 targ_ptr
, complain
, gen_tmpl
);
11065 processing_template_decl
= saved_processing_template_decl
;
11066 if (fndecl
== error_mark_node
)
11067 return error_mark_node
;
11069 /* Now we know the specialization, compute access previously
11071 push_access_scope (fndecl
);
11072 perform_deferred_access_checks ();
11073 pop_access_scope (fndecl
);
11074 pop_deferring_access_checks ();
11076 /* The DECL_TI_TEMPLATE should always be the immediate parent
11077 template, not the most general template. */
11078 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
11080 /* If we've just instantiated the main entry point for a function,
11081 instantiate all the alternate entry points as well. We do this
11082 by cloning the instantiation of the main entry point, not by
11083 instantiating the template clones. */
11084 if (TREE_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl
)))
11085 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
11090 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11091 arguments that are being used when calling it. TARGS is a vector
11092 into which the deduced template arguments are placed.
11094 Return zero for success, 2 for an incomplete match that doesn't resolve
11095 all the types, and 1 for complete failure. An error message will be
11096 printed only for an incomplete match.
11098 If FN is a conversion operator, or we are trying to produce a specific
11099 specialization, RETURN_TYPE is the return type desired.
11101 The EXPLICIT_TARGS are explicit template arguments provided via a
11104 The parameter STRICT is one of:
11107 We are deducing arguments for a function call, as in
11108 [temp.deduct.call].
11111 We are deducing arguments for a conversion function, as in
11112 [temp.deduct.conv].
11115 We are deducing arguments when doing an explicit instantiation
11116 as in [temp.explicit], when determining an explicit specialization
11117 as in [temp.expl.spec], or when taking the address of a function
11118 template, as in [temp.deduct.funcaddr]. */
11121 fn_type_unification (tree fn
,
11122 tree explicit_targs
,
11126 unification_kind_t strict
,
11132 bool incomplete_argument_packs_p
= false;
11134 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
11136 fntype
= TREE_TYPE (fn
);
11137 if (explicit_targs
)
11141 The specified template arguments must match the template
11142 parameters in kind (i.e., type, nontype, template), and there
11143 must not be more arguments than there are parameters;
11144 otherwise type deduction fails.
11146 Nontype arguments must match the types of the corresponding
11147 nontype template parameters, or must be convertible to the
11148 types of the corresponding nontype parameters as specified in
11149 _temp.arg.nontype_, otherwise type deduction fails.
11151 All references in the function type of the function template
11152 to the corresponding template parameters are replaced by the
11153 specified template argument values. If a substitution in a
11154 template parameter or in the function type of the function
11155 template results in an invalid type, type deduction fails. */
11156 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
11157 int i
, len
= TREE_VEC_LENGTH (tparms
);
11158 tree converted_args
;
11159 bool incomplete
= false;
11161 if (explicit_targs
== error_mark_node
)
11165 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
, tf_none
,
11166 /*require_all_args=*/false,
11167 /*use_default_args=*/false));
11168 if (converted_args
== error_mark_node
)
11171 /* Substitute the explicit args into the function type. This is
11172 necessary so that, for instance, explicitly declared function
11173 arguments can match null pointed constants. If we were given
11174 an incomplete set of explicit args, we must not do semantic
11175 processing during substitution as we could create partial
11177 for (i
= 0; i
< len
; i
++)
11179 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
11180 bool parameter_pack
= false;
11182 /* Dig out the actual parm. */
11183 if (TREE_CODE (parm
) == TYPE_DECL
11184 || TREE_CODE (parm
) == TEMPLATE_DECL
)
11186 parm
= TREE_TYPE (parm
);
11187 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
11189 else if (TREE_CODE (parm
) == PARM_DECL
)
11191 parm
= DECL_INITIAL (parm
);
11192 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
11195 if (parameter_pack
)
11199 template_parm_level_and_index (parm
, &level
, &idx
);
11201 /* Mark the argument pack as "incomplete". We could
11202 still deduce more arguments during unification. */
11203 targ
= TMPL_ARG (converted_args
, level
, idx
);
11206 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
11207 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
11208 = ARGUMENT_PACK_ARGS (targ
);
11211 /* We have some incomplete argument packs. */
11212 incomplete_argument_packs_p
= true;
11216 if (incomplete_argument_packs_p
)
11217 /* Any substitution is guaranteed to be incomplete if there
11218 are incomplete argument packs, because we can still deduce
11222 incomplete
= NUM_TMPL_ARGS (explicit_targs
) != NUM_TMPL_ARGS (targs
);
11224 processing_template_decl
+= incomplete
;
11225 fntype
= tsubst (fntype
, converted_args
, tf_none
, NULL_TREE
);
11226 processing_template_decl
-= incomplete
;
11228 if (fntype
== error_mark_node
)
11231 /* Place the explicitly specified arguments in TARGS. */
11232 for (i
= NUM_TMPL_ARGS (converted_args
); i
--;)
11233 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (converted_args
, i
);
11236 /* Never do unification on the 'this' parameter. */
11237 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
11241 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
11242 args
= tree_cons (NULL_TREE
, return_type
, args
);
11245 /* We allow incomplete unification without an error message here
11246 because the standard doesn't seem to explicitly prohibit it. Our
11247 callers must be ready to deal with unification failures in any
11249 result
= type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
11250 targs
, parms
, args
, /*subr=*/0,
11253 if (result
== 0 && incomplete_argument_packs_p
)
11255 int i
, len
= NUM_TMPL_ARGS (targs
);
11257 /* Clear the "incomplete" flags on all argument packs. */
11258 for (i
= 0; i
< len
; i
++)
11260 tree arg
= TREE_VEC_ELT (targs
, i
);
11261 if (ARGUMENT_PACK_P (arg
))
11263 ARGUMENT_PACK_INCOMPLETE_P (arg
) = 0;
11264 ARGUMENT_PACK_EXPLICIT_ARGS (arg
) = NULL_TREE
;
11270 /* All is well so far. Now, check:
11274 When all template arguments have been deduced, all uses of
11275 template parameters in nondeduced contexts are replaced with
11276 the corresponding deduced argument values. If the
11277 substitution results in an invalid type, as described above,
11278 type deduction fails. */
11279 if (tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
)
11280 == error_mark_node
)
11286 /* Adjust types before performing type deduction, as described in
11287 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11288 sections are symmetric. PARM is the type of a function parameter
11289 or the return type of the conversion function. ARG is the type of
11290 the argument passed to the call, or the type of the value
11291 initialized with the result of the conversion function.
11292 ARG_EXPR is the original argument expression, which may be null. */
11295 maybe_adjust_types_for_deduction (unification_kind_t strict
,
11309 /* Swap PARM and ARG throughout the remainder of this
11310 function; the handling is precisely symmetric since PARM
11311 will initialize ARG rather than vice versa. */
11319 /* There is nothing to do in this case. */
11323 gcc_unreachable ();
11326 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
11328 /* [temp.deduct.call]
11330 If P is not a reference type:
11332 --If A is an array type, the pointer type produced by the
11333 array-to-pointer standard conversion (_conv.array_) is
11334 used in place of A for type deduction; otherwise,
11336 --If A is a function type, the pointer type produced by
11337 the function-to-pointer standard conversion
11338 (_conv.func_) is used in place of A for type deduction;
11341 --If A is a cv-qualified type, the top level
11342 cv-qualifiers of A's type are ignored for type
11344 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
11345 *arg
= build_pointer_type (TREE_TYPE (*arg
));
11346 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
11347 *arg
= build_pointer_type (*arg
);
11349 *arg
= TYPE_MAIN_VARIANT (*arg
);
11352 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11353 of the form T&&, where T is a template parameter, and the argument
11354 is an lvalue, T is deduced as A& */
11355 if (TREE_CODE (*parm
) == REFERENCE_TYPE
11356 && TYPE_REF_IS_RVALUE (*parm
)
11357 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
11358 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
11359 && arg_expr
&& real_lvalue_p (arg_expr
))
11360 *arg
= build_reference_type (*arg
);
11362 /* [temp.deduct.call]
11364 If P is a cv-qualified type, the top level cv-qualifiers
11365 of P's type are ignored for type deduction. If P is a
11366 reference type, the type referred to by P is used for
11368 *parm
= TYPE_MAIN_VARIANT (*parm
);
11369 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
11371 *parm
= TREE_TYPE (*parm
);
11372 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
11375 /* DR 322. For conversion deduction, remove a reference type on parm
11376 too (which has been swapped into ARG). */
11377 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
11378 *arg
= TREE_TYPE (*arg
);
11383 /* Most parms like fn_type_unification.
11385 If SUBR is 1, we're being called recursively (to unify the
11386 arguments of a function or method parameter of a function
11390 type_unification_real (tree tparms
,
11395 unification_kind_t strict
,
11398 tree parm
, arg
, arg_expr
;
11400 int ntparms
= TREE_VEC_LENGTH (tparms
);
11402 int saw_undeduced
= 0;
11405 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
11406 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
11407 gcc_assert (!xargs
|| TREE_CODE (xargs
) == TREE_LIST
);
11408 gcc_assert (ntparms
> 0);
11413 sub_strict
= (UNIFY_ALLOW_OUTER_LEVEL
| UNIFY_ALLOW_MORE_CV_QUAL
11414 | UNIFY_ALLOW_DERIVED
);
11418 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
11422 sub_strict
= UNIFY_ALLOW_NONE
;
11426 gcc_unreachable ();
11433 while (parms
&& parms
!= void_list_node
11434 && args
&& args
!= void_list_node
)
11436 if (TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
11439 parm
= TREE_VALUE (parms
);
11440 parms
= TREE_CHAIN (parms
);
11441 arg
= TREE_VALUE (args
);
11442 args
= TREE_CHAIN (args
);
11445 if (arg
== error_mark_node
)
11447 if (arg
== unknown_type_node
)
11448 /* We can't deduce anything from this, but we might get all the
11449 template args from other function args. */
11452 /* Conversions will be performed on a function argument that
11453 corresponds with a function parameter that contains only
11454 non-deducible template parameters and explicitly specified
11455 template parameters. */
11456 if (!uses_template_parms (parm
))
11461 type
= TREE_TYPE (arg
);
11465 if (same_type_p (parm
, type
))
11467 if (strict
!= DEDUCE_EXACT
11468 && can_convert_arg (parm
, type
, TYPE_P (arg
) ? NULL_TREE
: arg
,
11477 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
11478 if (type_unknown_p (arg
))
11480 /* [temp.deduct.type]
11482 A template-argument can be deduced from a pointer to
11483 function or pointer to member function argument if
11484 the set of overloaded functions does not contain
11485 function templates and at most one of a set of
11486 overloaded functions provides a unique match. */
11487 if (resolve_overloaded_unification
11488 (tparms
, targs
, parm
, arg
, strict
, sub_strict
))
11494 arg
= unlowered_expr_type (arg
);
11495 if (arg
== error_mark_node
)
11500 int arg_strict
= sub_strict
;
11503 arg_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
,
11506 if (unify (tparms
, targs
, parm
, arg
, arg_strict
))
11513 && parms
!= void_list_node
11514 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
11516 /* Unify the remaining arguments with the pack expansion type. */
11518 tree parmvec
= make_tree_vec (1);
11522 /* Count the number of arguments that remain. */
11523 for (t
= args
; t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
11526 /* Allocate a TREE_VEC and copy in all of the arguments */
11527 argvec
= make_tree_vec (len
);
11528 for (i
= 0; args
&& args
!= void_list_node
; args
= TREE_CHAIN (args
))
11530 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (args
);
11534 /* Copy the parameter into parmvec. */
11535 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
11536 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
11537 /*call_args_p=*/true, /*subr=*/subr
))
11540 /* Advance to the end of the list of parameters. */
11541 parms
= TREE_CHAIN (parms
);
11544 /* Fail if we've reached the end of the parm list, and more args
11545 are present, and the parm list isn't variadic. */
11546 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
11548 /* Fail if parms are left and they don't have default values. */
11549 if (parms
&& parms
!= void_list_node
11550 && TREE_PURPOSE (parms
) == NULL_TREE
)
11554 for (i
= 0; i
< ntparms
; i
++)
11555 if (!TREE_VEC_ELT (targs
, i
))
11559 if (TREE_VEC_ELT (tparms
, i
) == error_mark_node
)
11562 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
11564 /* If this is an undeduced nontype parameter that depends on
11565 a type parameter, try another pass; its type may have been
11566 deduced from a later argument than the one from which
11567 this parameter can be deduced. */
11568 if (TREE_CODE (tparm
) == PARM_DECL
11569 && uses_template_parms (TREE_TYPE (tparm
))
11570 && !saw_undeduced
++)
11573 /* Core issue #226 (C++0x) [temp.deduct]:
11575 If a template argument has not been deduced, its
11576 default template argument, if any, is used.
11578 When we are in C++98 mode, TREE_PURPOSE will either
11579 be NULL_TREE or ERROR_MARK_NODE, so we do not need
11580 to explicitly check cxx_dialect here. */
11581 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
11583 tree arg
= tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)),
11584 targs
, tf_none
, NULL_TREE
);
11585 if (arg
== error_mark_node
)
11589 TREE_VEC_ELT (targs
, i
) = arg
;
11594 /* If the type parameter is a parameter pack, then it will
11595 be deduced to an empty parameter pack. */
11596 if (template_parameter_pack_p (tparm
))
11600 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
11602 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
11603 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
11604 TREE_CONSTANT (arg
) = 1;
11607 arg
= make_node (TYPE_ARGUMENT_PACK
);
11609 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
11611 TREE_VEC_ELT (targs
, i
) = arg
;
11621 /* Subroutine of type_unification_real. Args are like the variables
11622 at the call site. ARG is an overloaded function (or template-id);
11623 we try deducing template args from each of the overloads, and if
11624 only one succeeds, we go with that. Modifies TARGS and returns
11625 true on success. */
11628 resolve_overloaded_unification (tree tparms
,
11632 unification_kind_t strict
,
11635 tree tempargs
= copy_node (targs
);
11639 if (TREE_CODE (arg
) == ADDR_EXPR
)
11641 arg
= TREE_OPERAND (arg
, 0);
11647 if (TREE_CODE (arg
) == COMPONENT_REF
)
11648 /* Handle `&x' where `x' is some static or non-static member
11650 arg
= TREE_OPERAND (arg
, 1);
11652 if (TREE_CODE (arg
) == OFFSET_REF
)
11653 arg
= TREE_OPERAND (arg
, 1);
11655 /* Strip baselink information. */
11656 if (BASELINK_P (arg
))
11657 arg
= BASELINK_FUNCTIONS (arg
);
11659 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
11661 /* If we got some explicit template args, we need to plug them into
11662 the affected templates before we try to unify, in case the
11663 explicit args will completely resolve the templates in question. */
11665 tree expl_subargs
= TREE_OPERAND (arg
, 1);
11666 arg
= TREE_OPERAND (arg
, 0);
11668 for (; arg
; arg
= OVL_NEXT (arg
))
11670 tree fn
= OVL_CURRENT (arg
);
11671 tree subargs
, elem
;
11673 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
11676 subargs
= get_bindings (fn
, DECL_TEMPLATE_RESULT (fn
),
11677 expl_subargs
, /*check_ret=*/false);
11680 elem
= tsubst (TREE_TYPE (fn
), subargs
, tf_none
, NULL_TREE
);
11681 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
11682 elem
, strict
, sub_strict
, addr_p
);
11686 else if (TREE_CODE (arg
) != OVERLOAD
11687 && TREE_CODE (arg
) != FUNCTION_DECL
)
11688 /* If ARG is, for example, "(0, &f)" then its type will be unknown
11689 -- but the deduction does not succeed because the expression is
11690 not just the function on its own. */
11693 for (; arg
; arg
= OVL_NEXT (arg
))
11694 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
11695 TREE_TYPE (OVL_CURRENT (arg
)),
11696 strict
, sub_strict
, addr_p
);
11698 /* [temp.deduct.type] A template-argument can be deduced from a pointer
11699 to function or pointer to member function argument if the set of
11700 overloaded functions does not contain function templates and at most
11701 one of a set of overloaded functions provides a unique match.
11703 So if we found multiple possibilities, we return success but don't
11704 deduce anything. */
11708 int i
= TREE_VEC_LENGTH (targs
);
11710 if (TREE_VEC_ELT (tempargs
, i
))
11711 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
11719 /* Subroutine of resolve_overloaded_unification; does deduction for a single
11720 overload. Fills TARGS with any deduced arguments, or error_mark_node if
11721 different overloads deduce different arguments for a given parm.
11722 ADDR_P is true if the expression for which deduction is being
11723 performed was of the form "& fn" rather than simply "fn".
11725 Returns 1 on success. */
11728 try_one_overload (tree tparms
,
11733 unification_kind_t strict
,
11741 /* [temp.deduct.type] A template-argument can be deduced from a pointer
11742 to function or pointer to member function argument if the set of
11743 overloaded functions does not contain function templates and at most
11744 one of a set of overloaded functions provides a unique match.
11746 So if this is a template, just return success. */
11748 if (uses_template_parms (arg
))
11751 if (TREE_CODE (arg
) == METHOD_TYPE
)
11752 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
11754 arg
= build_pointer_type (arg
);
11756 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
11758 /* We don't copy orig_targs for this because if we have already deduced
11759 some template args from previous args, unify would complain when we
11760 try to deduce a template parameter for the same argument, even though
11761 there isn't really a conflict. */
11762 nargs
= TREE_VEC_LENGTH (targs
);
11763 tempargs
= make_tree_vec (nargs
);
11765 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
) != 0)
11768 /* First make sure we didn't deduce anything that conflicts with
11769 explicitly specified args. */
11770 for (i
= nargs
; i
--; )
11772 tree elt
= TREE_VEC_ELT (tempargs
, i
);
11773 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
11777 else if (uses_template_parms (elt
))
11778 /* Since we're unifying against ourselves, we will fill in
11779 template args used in the function parm list with our own
11780 template parms. Discard them. */
11781 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
11782 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
11786 for (i
= nargs
; i
--; )
11788 tree elt
= TREE_VEC_ELT (tempargs
, i
);
11791 TREE_VEC_ELT (targs
, i
) = elt
;
11797 /* PARM is a template class (perhaps with unbound template
11798 parameters). ARG is a fully instantiated type. If ARG can be
11799 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
11800 TARGS are as for unify. */
11803 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
)
11805 tree copy_of_targs
;
11807 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
11808 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
11809 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
11812 /* We need to make a new template argument vector for the call to
11813 unify. If we used TARGS, we'd clutter it up with the result of
11814 the attempted unification, even if this class didn't work out.
11815 We also don't want to commit ourselves to all the unifications
11816 we've already done, since unification is supposed to be done on
11817 an argument-by-argument basis. In other words, consider the
11818 following pathological case:
11820 template <int I, int J, int K>
11823 template <int I, int J>
11824 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
11826 template <int I, int J, int K>
11827 void f(S<I, J, K>, S<I, I, I>);
11836 Now, by the time we consider the unification involving `s2', we
11837 already know that we must have `f<0, 0, 0>'. But, even though
11838 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
11839 because there are two ways to unify base classes of S<0, 1, 2>
11840 with S<I, I, I>. If we kept the already deduced knowledge, we
11841 would reject the possibility I=1. */
11842 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
11844 /* If unification failed, we're done. */
11845 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
11846 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
))
11852 /* Given a template type PARM and a class type ARG, find the unique
11853 base type in ARG that is an instance of PARM. We do not examine
11854 ARG itself; only its base-classes. If there is not exactly one
11855 appropriate base class, return NULL_TREE. PARM may be the type of
11856 a partial specialization, as well as a plain template type. Used
11860 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
)
11862 tree rval
= NULL_TREE
;
11865 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg
)));
11867 binfo
= TYPE_BINFO (complete_type (arg
));
11869 /* The type could not be completed. */
11872 /* Walk in inheritance graph order. The search order is not
11873 important, and this avoids multiple walks of virtual bases. */
11874 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
11876 tree r
= try_class_unification (tparms
, targs
, parm
, BINFO_TYPE (binfo
));
11880 /* If there is more than one satisfactory baseclass, then:
11884 If they yield more than one possible deduced A, the type
11888 if (rval
&& !same_type_p (r
, rval
))
11898 /* Returns the level of DECL, which declares a template parameter. */
11901 template_decl_level (tree decl
)
11903 switch (TREE_CODE (decl
))
11906 case TEMPLATE_DECL
:
11907 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
11910 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
11913 gcc_unreachable ();
11918 /* Decide whether ARG can be unified with PARM, considering only the
11919 cv-qualifiers of each type, given STRICT as documented for unify.
11920 Returns nonzero iff the unification is OK on that basis. */
11923 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
11925 int arg_quals
= cp_type_quals (arg
);
11926 int parm_quals
= cp_type_quals (parm
);
11928 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
11929 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
11931 /* Although a CVR qualifier is ignored when being applied to a
11932 substituted template parameter ([8.3.2]/1 for example), that
11933 does not apply during deduction [14.8.2.4]/1, (even though
11934 that is not explicitly mentioned, [14.8.2.4]/9 indicates
11935 this). Except when we're allowing additional CV qualifiers
11936 at the outer level [14.8.2.1]/3,1st bullet. */
11937 if ((TREE_CODE (arg
) == REFERENCE_TYPE
11938 || TREE_CODE (arg
) == FUNCTION_TYPE
11939 || TREE_CODE (arg
) == METHOD_TYPE
)
11940 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
11943 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
11944 && (parm_quals
& TYPE_QUAL_RESTRICT
))
11948 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
11949 && (arg_quals
& parm_quals
) != parm_quals
)
11952 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
11953 && (parm_quals
& arg_quals
) != arg_quals
)
11959 /* Determines the LEVEL and INDEX for the template parameter PARM. */
11961 template_parm_level_and_index (tree parm
, int* level
, int* index
)
11963 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
11964 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
11965 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
11967 *index
= TEMPLATE_TYPE_IDX (parm
);
11968 *level
= TEMPLATE_TYPE_LEVEL (parm
);
11972 *index
= TEMPLATE_PARM_IDX (parm
);
11973 *level
= TEMPLATE_PARM_LEVEL (parm
);
11977 /* Unifies the remaining arguments in PACKED_ARGS with the pack
11978 expansion at the end of PACKED_PARMS. Returns 0 if the type
11979 deduction succeeds, 1 otherwise. STRICT is the same as in
11980 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
11981 call argument list. We'll need to adjust the arguments to make them
11982 types. SUBR tells us if this is from a recursive call to
11983 type_unification_real. */
11985 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
11986 tree packed_args
, int strict
, bool call_args_p
,
11990 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
11991 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
11992 tree pack
, packs
= NULL_TREE
;
11993 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
11994 int len
= TREE_VEC_LENGTH (packed_args
);
11996 /* Determine the parameter packs we will be deducing from the
11997 pattern, and record their current deductions. */
11998 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
11999 pack
; pack
= TREE_CHAIN (pack
))
12001 tree parm_pack
= TREE_VALUE (pack
);
12004 /* Determine the index and level of this parameter pack. */
12005 template_parm_level_and_index (parm_pack
, &level
, &idx
);
12007 /* Keep track of the parameter packs and their corresponding
12009 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
12010 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
12013 /* Loop through all of the arguments that have not yet been
12014 unified and unify each with the pattern. */
12015 for (i
= start
; i
< len
; i
++)
12017 tree parm
= pattern
;
12019 /* For each parameter pack, clear out the deduced value so that
12020 we can deduce it again. */
12021 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12024 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12026 TMPL_ARG (targs
, level
, idx
) = NULL_TREE
;
12029 /* Unify the pattern with the current argument. */
12031 tree arg
= TREE_VEC_ELT (packed_args
, i
);
12032 int arg_strict
= strict
;
12033 bool skip_arg_p
= false;
12039 /* This mirrors what we do in type_unification_real. */
12043 sub_strict
= (UNIFY_ALLOW_OUTER_LEVEL
12044 | UNIFY_ALLOW_MORE_CV_QUAL
12045 | UNIFY_ALLOW_DERIVED
);
12049 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
12053 sub_strict
= UNIFY_ALLOW_NONE
;
12057 gcc_unreachable ();
12062 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
12063 if (type_unknown_p (arg
))
12065 /* [temp.deduct.type] A template-argument can be
12066 deduced from a pointer to function or pointer
12067 to member function argument if the set of
12068 overloaded functions does not contain function
12069 templates and at most one of a set of
12070 overloaded functions provides a unique
12073 if (resolve_overloaded_unification
12074 (tparms
, targs
, parm
, arg
, strict
, sub_strict
)
12082 arg
= TREE_TYPE (arg
);
12083 if (arg
== error_mark_node
)
12088 arg_strict
= sub_strict
;
12092 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
12097 if (unify (tparms
, targs
, parm
, arg
, arg_strict
))
12102 /* For each parameter pack, collect the deduced value. */
12103 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12106 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12108 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
12109 TMPL_ARG (targs
, level
, idx
);
12113 /* Verify that the results of unification with the parameter packs
12114 produce results consistent with what we've seen before, and make
12115 the deduced argument packs available. */
12116 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12118 tree old_pack
= TREE_VALUE (pack
);
12119 tree new_args
= TREE_TYPE (pack
);
12121 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
12123 /* Prepend the explicit arguments onto NEW_ARGS. */
12124 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
12125 tree old_args
= new_args
;
12126 int i
, explicit_len
= TREE_VEC_LENGTH (explicit_args
);
12127 int len
= explicit_len
+ TREE_VEC_LENGTH (old_args
);
12129 /* Copy the explicit arguments. */
12130 new_args
= make_tree_vec (len
);
12131 for (i
= 0; i
< explicit_len
; i
++)
12132 TREE_VEC_ELT (new_args
, i
) = TREE_VEC_ELT (explicit_args
, i
);
12134 /* Copy the deduced arguments. */
12135 for (; i
< len
; i
++)
12136 TREE_VEC_ELT (new_args
, i
) =
12137 TREE_VEC_ELT (old_args
, i
- explicit_len
);
12145 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12147 /* Build the deduced *_ARGUMENT_PACK. */
12148 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
12150 result
= make_node (NONTYPE_ARGUMENT_PACK
);
12151 TREE_TYPE (result
) =
12152 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
12153 TREE_CONSTANT (result
) = 1;
12156 result
= make_node (TYPE_ARGUMENT_PACK
);
12158 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
12160 /* Note the deduced argument packs for this parameter
12162 TMPL_ARG (targs
, level
, idx
) = result
;
12164 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
12165 && (ARGUMENT_PACK_ARGS (old_pack
)
12166 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
12168 /* We only had the explicitly-provided arguments before, but
12169 now we have a complete set of arguments. */
12171 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
12172 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12174 /* Keep the original deduced argument pack. */
12175 TMPL_ARG (targs
, level
, idx
) = old_pack
;
12177 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
12178 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
12179 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
12181 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack
),
12183 /* Inconsistent unification of this parameter pack. */
12189 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12191 /* Keep the original deduced argument pack. */
12192 TMPL_ARG (targs
, level
, idx
) = old_pack
;
12199 /* Deduce the value of template parameters. TPARMS is the (innermost)
12200 set of template parameters to a template. TARGS is the bindings
12201 for those template parameters, as determined thus far; TARGS may
12202 include template arguments for outer levels of template parameters
12203 as well. PARM is a parameter to a template function, or a
12204 subcomponent of that parameter; ARG is the corresponding argument.
12205 This function attempts to match PARM with ARG in a manner
12206 consistent with the existing assignments in TARGS. If more values
12207 are deduced, then TARGS is updated.
12209 Returns 0 if the type deduction succeeds, 1 otherwise. The
12210 parameter STRICT is a bitwise or of the following flags:
12213 Require an exact match between PARM and ARG.
12214 UNIFY_ALLOW_MORE_CV_QUAL:
12215 Allow the deduced ARG to be more cv-qualified (by qualification
12216 conversion) than ARG.
12217 UNIFY_ALLOW_LESS_CV_QUAL:
12218 Allow the deduced ARG to be less cv-qualified than ARG.
12219 UNIFY_ALLOW_DERIVED:
12220 Allow the deduced ARG to be a template base class of ARG,
12221 or a pointer to a template base class of the type pointed to by
12223 UNIFY_ALLOW_INTEGER:
12224 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12225 case for more information.
12226 UNIFY_ALLOW_OUTER_LEVEL:
12227 This is the outermost level of a deduction. Used to determine validity
12228 of qualification conversions. A valid qualification conversion must
12229 have const qualified pointers leading up to the inner type which
12230 requires additional CV quals, except at the outer level, where const
12231 is not required [conv.qual]. It would be normal to set this flag in
12232 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12233 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12234 This is the outermost level of a deduction, and PARM can be more CV
12235 qualified at this point.
12236 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12237 This is the outermost level of a deduction, and PARM can be less CV
12238 qualified at this point. */
12241 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
)
12246 int strict_in
= strict
;
12248 /* I don't think this will do the right thing with respect to types.
12249 But the only case I've seen it in so far has been array bounds, where
12250 signedness is the only information lost, and I think that will be
12252 while (TREE_CODE (parm
) == NOP_EXPR
)
12253 parm
= TREE_OPERAND (parm
, 0);
12255 if (arg
== error_mark_node
)
12257 if (arg
== unknown_type_node
)
12258 /* We can't deduce anything from this, but we might get all the
12259 template args from other function args. */
12262 /* If PARM uses template parameters, then we can't bail out here,
12263 even if ARG == PARM, since we won't record unifications for the
12264 template parameters. We might need them if we're trying to
12265 figure out which of two things is more specialized. */
12266 if (arg
== parm
&& !uses_template_parms (parm
))
12269 /* Immediately reject some pairs that won't unify because of
12270 cv-qualification mismatches. */
12271 if (TREE_CODE (arg
) == TREE_CODE (parm
)
12273 /* It is the elements of the array which hold the cv quals of an array
12274 type, and the elements might be template type parms. We'll check
12275 when we recurse. */
12276 && TREE_CODE (arg
) != ARRAY_TYPE
12277 /* We check the cv-qualifiers when unifying with template type
12278 parameters below. We want to allow ARG `const T' to unify with
12279 PARM `T' for example, when computing which of two templates
12280 is more specialized, for example. */
12281 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
12282 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
12285 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
12286 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
12287 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
12288 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
12289 strict
&= ~UNIFY_ALLOW_DERIVED
;
12290 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
12291 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
12293 switch (TREE_CODE (parm
))
12295 case TYPENAME_TYPE
:
12297 case UNBOUND_CLASS_TEMPLATE
:
12298 /* In a type which contains a nested-name-specifier, template
12299 argument values cannot be deduced for template parameters used
12300 within the nested-name-specifier. */
12303 case TEMPLATE_TYPE_PARM
:
12304 case TEMPLATE_TEMPLATE_PARM
:
12305 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12306 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
12307 if (tparm
== error_mark_node
)
12310 if (TEMPLATE_TYPE_LEVEL (parm
)
12311 != template_decl_level (tparm
))
12312 /* The PARM is not one we're trying to unify. Just check
12313 to see if it matches ARG. */
12314 return (TREE_CODE (arg
) == TREE_CODE (parm
)
12315 && same_type_p (parm
, arg
)) ? 0 : 1;
12316 idx
= TEMPLATE_TYPE_IDX (parm
);
12317 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
12318 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
12320 /* Check for mixed types and values. */
12321 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
12322 && TREE_CODE (tparm
) != TYPE_DECL
)
12323 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
12324 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
12327 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12329 /* ARG must be constructed from a template class or a template
12330 template parameter. */
12331 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
12332 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
12336 tree parmvec
= TYPE_TI_ARGS (parm
);
12337 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
12339 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg
));
12342 /* The resolution to DR150 makes clear that default
12343 arguments for an N-argument may not be used to bind T
12344 to a template template parameter with fewer than N
12345 parameters. It is not safe to permit the binding of
12346 default arguments as an extension, as that may change
12347 the meaning of a conforming program. Consider:
12349 struct Dense { static const unsigned int dim = 1; };
12351 template <template <typename> class View,
12353 void operator+(float, View<Block> const&);
12355 template <typename Block,
12356 unsigned int Dim = Block::dim>
12357 struct Lvalue_proxy { operator float() const; };
12361 Lvalue_proxy<Dense> p;
12366 Here, if Lvalue_proxy is permitted to bind to View, then
12367 the global operator+ will be used; if they are not, the
12368 Lvalue_proxy will be converted to float. */
12369 if (coerce_template_parms (argtmplvec
, parmvec
,
12370 TYPE_TI_TEMPLATE (parm
),
12372 /*require_all_args=*/true,
12373 /*use_default_args=*/false)
12374 == error_mark_node
)
12377 /* Deduce arguments T, i from TT<T> or TT<i>.
12378 We check each element of PARMVEC and ARGVEC individually
12379 rather than the whole TREE_VEC since they can have
12380 different number of elements. */
12382 for (i
= 0; i
< TREE_VEC_LENGTH (parmvec
); ++i
)
12384 if (unify (tparms
, targs
,
12385 TREE_VEC_ELT (parmvec
, i
),
12386 TREE_VEC_ELT (argvec
, i
),
12391 arg
= TYPE_TI_TEMPLATE (arg
);
12393 /* Fall through to deduce template name. */
12396 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
12397 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12399 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
12401 /* Simple cases: Value already set, does match or doesn't. */
12402 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
12409 /* If PARM is `const T' and ARG is only `int', we don't have
12410 a match unless we are allowing additional qualification.
12411 If ARG is `const int' and PARM is just `T' that's OK;
12412 that binds `const int' to `T'. */
12413 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
12417 /* Consider the case where ARG is `const volatile int' and
12418 PARM is `const T'. Then, T should be `volatile int'. */
12419 arg
= cp_build_qualified_type_real
12420 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
12421 if (arg
== error_mark_node
)
12424 /* Simple cases: Value already set, does match or doesn't. */
12425 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
12430 /* Make sure that ARG is not a variable-sized array. (Note
12431 that were talking about variable-sized arrays (like
12432 `int[n]'), rather than arrays of unknown size (like
12433 `int[]').) We'll get very confused by such a type since
12434 the bound of the array will not be computable in an
12435 instantiation. Besides, such types are not allowed in
12436 ISO C++, so we can do as we please here. */
12437 if (variably_modified_type_p (arg
, NULL_TREE
))
12441 /* If ARG is a parameter pack or an expansion, we cannot unify
12442 against it unless PARM is also a parameter pack. */
12443 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
12444 && !template_parameter_pack_p (parm
))
12447 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
12450 case TEMPLATE_PARM_INDEX
:
12451 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
12452 if (tparm
== error_mark_node
)
12455 if (TEMPLATE_PARM_LEVEL (parm
)
12456 != template_decl_level (tparm
))
12457 /* The PARM is not one we're trying to unify. Just check
12458 to see if it matches ARG. */
12459 return !(TREE_CODE (arg
) == TREE_CODE (parm
)
12460 && cp_tree_equal (parm
, arg
));
12462 idx
= TEMPLATE_PARM_IDX (parm
);
12463 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
12466 return !cp_tree_equal (targ
, arg
);
12468 /* [temp.deduct.type] If, in the declaration of a function template
12469 with a non-type template-parameter, the non-type
12470 template-parameter is used in an expression in the function
12471 parameter-list and, if the corresponding template-argument is
12472 deduced, the template-argument type shall match the type of the
12473 template-parameter exactly, except that a template-argument
12474 deduced from an array bound may be of any integral type.
12475 The non-type parameter might use already deduced type parameters. */
12476 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
12477 if (!TREE_TYPE (arg
))
12478 /* Template-parameter dependent expression. Just accept it for now.
12479 It will later be processed in convert_template_argument. */
12481 else if (same_type_p (TREE_TYPE (arg
), tparm
))
12483 else if ((strict
& UNIFY_ALLOW_INTEGER
)
12484 && (TREE_CODE (tparm
) == INTEGER_TYPE
12485 || TREE_CODE (tparm
) == BOOLEAN_TYPE
))
12486 /* Convert the ARG to the type of PARM; the deduced non-type
12487 template argument must exactly match the types of the
12488 corresponding parameter. */
12489 arg
= fold (build_nop (TREE_TYPE (parm
), arg
));
12490 else if (uses_template_parms (tparm
))
12491 /* We haven't deduced the type of this parameter yet. Try again
12497 /* If ARG is a parameter pack or an expansion, we cannot unify
12498 against it unless PARM is also a parameter pack. */
12499 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
12500 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
12503 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
12508 /* A pointer-to-member constant can be unified only with
12509 another constant. */
12510 if (TREE_CODE (arg
) != PTRMEM_CST
)
12513 /* Just unify the class member. It would be useless (and possibly
12514 wrong, depending on the strict flags) to unify also
12515 PTRMEM_CST_CLASS, because we want to be sure that both parm and
12516 arg refer to the same variable, even if through different
12517 classes. For instance:
12519 struct A { int x; };
12522 Unification of &A::x and &B::x must succeed. */
12523 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
12524 PTRMEM_CST_MEMBER (arg
), strict
);
12529 if (TREE_CODE (arg
) != POINTER_TYPE
)
12532 /* [temp.deduct.call]
12534 A can be another pointer or pointer to member type that can
12535 be converted to the deduced A via a qualification
12536 conversion (_conv.qual_).
12538 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
12539 This will allow for additional cv-qualification of the
12540 pointed-to types if appropriate. */
12542 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
12543 /* The derived-to-base conversion only persists through one
12544 level of pointers. */
12545 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
12547 return unify (tparms
, targs
, TREE_TYPE (parm
),
12548 TREE_TYPE (arg
), strict
);
12551 case REFERENCE_TYPE
:
12552 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
12554 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
12555 strict
& UNIFY_ALLOW_MORE_CV_QUAL
);
12558 if (TREE_CODE (arg
) != ARRAY_TYPE
)
12560 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
12561 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
12563 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
12570 /* Our representation of array types uses "N - 1" as the
12571 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
12572 not an integer constant. We cannot unify arbitrarily
12573 complex expressions, so we eliminate the MINUS_EXPRs
12575 parm_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (parm
));
12576 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
12579 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
12580 parm_max
= TREE_OPERAND (parm_max
, 0);
12582 arg_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (arg
));
12583 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
12586 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
12587 trying to unify the type of a variable with the type
12588 of a template parameter. For example:
12590 template <unsigned int N>
12591 void f (char (&) [N]);
12598 Here, the type of the ARG will be "int [g(i)]", and
12599 may be a SAVE_EXPR, etc. */
12600 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
12602 arg_max
= TREE_OPERAND (arg_max
, 0);
12605 /* If only one of the bounds used a MINUS_EXPR, compensate
12606 by adding one to the other bound. */
12607 if (parm_cst
&& !arg_cst
)
12608 parm_max
= fold_build2 (PLUS_EXPR
,
12612 else if (arg_cst
&& !parm_cst
)
12613 arg_max
= fold_build2 (PLUS_EXPR
,
12618 if (unify (tparms
, targs
, parm_max
, arg_max
, UNIFY_ALLOW_INTEGER
))
12621 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
12622 strict
& UNIFY_ALLOW_MORE_CV_QUAL
);
12629 case ENUMERAL_TYPE
:
12631 if (TREE_CODE (arg
) != TREE_CODE (parm
))
12634 /* We have already checked cv-qualification at the top of the
12636 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
12639 /* As far as unification is concerned, this wins. Later checks
12640 will invalidate it if necessary. */
12643 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
12644 /* Type INTEGER_CST can come from ordinary constant template args. */
12646 while (TREE_CODE (arg
) == NOP_EXPR
)
12647 arg
= TREE_OPERAND (arg
, 0);
12649 if (TREE_CODE (arg
) != INTEGER_CST
)
12651 return !tree_int_cst_equal (parm
, arg
);
12656 if (TREE_CODE (arg
) != TREE_VEC
)
12658 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
12660 for (i
= 0; i
< TREE_VEC_LENGTH (parm
); ++i
)
12661 if (unify (tparms
, targs
,
12662 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
12670 if (TREE_CODE (arg
) != TREE_CODE (parm
))
12673 if (TYPE_PTRMEMFUNC_P (parm
))
12675 if (!TYPE_PTRMEMFUNC_P (arg
))
12678 return unify (tparms
, targs
,
12679 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
12680 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
12684 if (CLASSTYPE_TEMPLATE_INFO (parm
))
12686 tree t
= NULL_TREE
;
12688 if (strict_in
& UNIFY_ALLOW_DERIVED
)
12690 /* First, we try to unify the PARM and ARG directly. */
12691 t
= try_class_unification (tparms
, targs
,
12696 /* Fallback to the special case allowed in
12697 [temp.deduct.call]:
12699 If P is a class, and P has the form
12700 template-id, then A can be a derived class of
12701 the deduced A. Likewise, if P is a pointer to
12702 a class of the form template-id, A can be a
12703 pointer to a derived class pointed to by the
12705 t
= get_template_base (tparms
, targs
, parm
, arg
);
12711 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
12712 && (CLASSTYPE_TI_TEMPLATE (parm
)
12713 == CLASSTYPE_TI_TEMPLATE (arg
)))
12714 /* Perhaps PARM is something like S<U> and ARG is S<int>.
12715 Then, we should unify `int' and `U'. */
12718 /* There's no chance of unification succeeding. */
12721 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
12722 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
);
12724 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
12729 case FUNCTION_TYPE
:
12730 if (TREE_CODE (arg
) != TREE_CODE (parm
))
12733 /* CV qualifications for methods can never be deduced, they must
12734 match exactly. We need to check them explicitly here,
12735 because type_unification_real treats them as any other
12736 cvqualified parameter. */
12737 if (TREE_CODE (parm
) == METHOD_TYPE
12738 && (!check_cv_quals_for_unify
12740 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg
))),
12741 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm
))))))
12744 if (unify (tparms
, targs
, TREE_TYPE (parm
),
12745 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
))
12747 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
12748 TYPE_ARG_TYPES (arg
), 1, DEDUCE_EXACT
,
12752 /* Unify a pointer to member with a pointer to member function, which
12753 deduces the type of the member as a function type. */
12754 if (TYPE_PTRMEMFUNC_P (arg
))
12758 cp_cv_quals cv_quals
;
12760 /* Check top-level cv qualifiers */
12761 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
12764 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
12765 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
), UNIFY_ALLOW_NONE
))
12768 /* Determine the type of the function we are unifying against. */
12769 method_type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg
));
12771 build_function_type (TREE_TYPE (method_type
),
12772 TREE_CHAIN (TYPE_ARG_TYPES (method_type
)));
12774 /* Extract the cv-qualifiers of the member function from the
12775 implicit object parameter and place them on the function
12776 type to be restored later. */
12778 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type
))));
12779 fntype
= build_qualified_type (fntype
, cv_quals
);
12780 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
);
12783 if (TREE_CODE (arg
) != OFFSET_TYPE
)
12785 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
12786 TYPE_OFFSET_BASETYPE (arg
), UNIFY_ALLOW_NONE
))
12788 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
12792 if (DECL_TEMPLATE_PARM_P (parm
))
12793 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
);
12794 if (arg
!= integral_constant_value (parm
))
12799 case TEMPLATE_DECL
:
12800 /* Matched cases are handled by the ARG == PARM test above. */
12803 case TYPE_ARGUMENT_PACK
:
12804 case NONTYPE_ARGUMENT_PACK
:
12806 tree packed_parms
= ARGUMENT_PACK_ARGS (parm
);
12807 tree packed_args
= ARGUMENT_PACK_ARGS (arg
);
12808 int i
, len
= TREE_VEC_LENGTH (packed_parms
);
12809 int argslen
= TREE_VEC_LENGTH (packed_args
);
12810 int parm_variadic_p
= 0;
12812 /* Check if the parameters end in a pack, making them variadic. */
12814 && PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms
, len
- 1)))
12815 parm_variadic_p
= 1;
12817 /* If we don't have enough arguments to satisfy the parameters
12818 (not counting the pack expression at the end), or we have
12819 too many arguments for a parameter list that doesn't end in
12820 a pack expression, we can't unify. */
12821 if (argslen
< (len
- parm_variadic_p
)
12822 || (argslen
> len
&& !parm_variadic_p
))
12825 /* Unify all of the parameters that precede the (optional)
12826 pack expression. */
12827 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
12829 if (unify (tparms
, targs
, TREE_VEC_ELT (packed_parms
, i
),
12830 TREE_VEC_ELT (packed_args
, i
), strict
))
12834 if (parm_variadic_p
)
12835 return unify_pack_expansion (tparms
, targs
,
12836 packed_parms
, packed_args
,
12837 strict
, /*call_args_p=*/false,
12845 case DECLTYPE_TYPE
:
12846 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
12851 gcc_assert (EXPR_P (parm
));
12853 /* We must be looking at an expression. This can happen with
12857 void foo(S<I>, S<I + 2>);
12859 This is a "nondeduced context":
12863 The nondeduced contexts are:
12865 --A type that is a template-id in which one or more of
12866 the template-arguments is an expression that references
12867 a template-parameter.
12869 In these cases, we assume deduction succeeded, but don't
12870 actually infer any unifications. */
12872 if (!uses_template_parms (parm
)
12873 && !template_args_equal (parm
, arg
))
12880 /* Note that DECL can be defined in this translation unit, if
12884 mark_definable (tree decl
)
12887 DECL_NOT_REALLY_EXTERN (decl
) = 1;
12888 FOR_EACH_CLONE (clone
, decl
)
12889 DECL_NOT_REALLY_EXTERN (clone
) = 1;
12892 /* Called if RESULT is explicitly instantiated, or is a member of an
12893 explicitly instantiated class. */
12896 mark_decl_instantiated (tree result
, int extern_p
)
12898 SET_DECL_EXPLICIT_INSTANTIATION (result
);
12900 /* If this entity has already been written out, it's too late to
12901 make any modifications. */
12902 if (TREE_ASM_WRITTEN (result
))
12905 if (TREE_CODE (result
) != FUNCTION_DECL
)
12906 /* The TREE_PUBLIC flag for function declarations will have been
12907 set correctly by tsubst. */
12908 TREE_PUBLIC (result
) = 1;
12910 /* This might have been set by an earlier implicit instantiation. */
12911 DECL_COMDAT (result
) = 0;
12914 DECL_NOT_REALLY_EXTERN (result
) = 0;
12917 mark_definable (result
);
12918 /* Always make artificials weak. */
12919 if (DECL_ARTIFICIAL (result
) && flag_weak
)
12920 comdat_linkage (result
);
12921 /* For WIN32 we also want to put explicit instantiations in
12922 linkonce sections. */
12923 else if (TREE_PUBLIC (result
))
12924 maybe_make_one_only (result
);
12927 /* If EXTERN_P, then this function will not be emitted -- unless
12928 followed by an explicit instantiation, at which point its linkage
12929 will be adjusted. If !EXTERN_P, then this function will be
12930 emitted here. In neither circumstance do we want
12931 import_export_decl to adjust the linkage. */
12932 DECL_INTERFACE_KNOWN (result
) = 1;
12935 /* Given two function templates PAT1 and PAT2, return:
12937 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
12938 -1 if PAT2 is more specialized than PAT1.
12939 0 if neither is more specialized.
12941 LEN indicates the number of parameters we should consider
12942 (defaulted parameters should not be considered).
12944 The 1998 std underspecified function template partial ordering, and
12945 DR214 addresses the issue. We take pairs of arguments, one from
12946 each of the templates, and deduce them against each other. One of
12947 the templates will be more specialized if all the *other*
12948 template's arguments deduce against its arguments and at least one
12949 of its arguments *does* *not* deduce against the other template's
12950 corresponding argument. Deduction is done as for class templates.
12951 The arguments used in deduction have reference and top level cv
12952 qualifiers removed. Iff both arguments were originally reference
12953 types *and* deduction succeeds in both directions, the template
12954 with the more cv-qualified argument wins for that pairing (if
12955 neither is more cv-qualified, they both are equal). Unlike regular
12956 deduction, after all the arguments have been deduced in this way,
12957 we do *not* verify the deduced template argument values can be
12958 substituted into non-deduced contexts, nor do we have to verify
12959 that all template arguments have been deduced. */
12962 more_specialized_fn (tree pat1
, tree pat2
, int len
)
12964 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
12965 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
12966 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
12967 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
12968 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
12969 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
12970 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
12971 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
12975 /* Remove the this parameter from non-static member functions. If
12976 one is a non-static member function and the other is not a static
12977 member function, remove the first parameter from that function
12978 also. This situation occurs for operator functions where we
12979 locate both a member function (with this pointer) and non-member
12980 operator (with explicit first operand). */
12981 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
12983 len
--; /* LEN is the number of significant arguments for DECL1 */
12984 args1
= TREE_CHAIN (args1
);
12985 if (!DECL_STATIC_FUNCTION_P (decl2
))
12986 args2
= TREE_CHAIN (args2
);
12988 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
12990 args2
= TREE_CHAIN (args2
);
12991 if (!DECL_STATIC_FUNCTION_P (decl1
))
12994 args1
= TREE_CHAIN (args1
);
12998 /* If only one is a conversion operator, they are unordered. */
12999 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
13002 /* Consider the return type for a conversion function */
13003 if (DECL_CONV_FN_P (decl1
))
13005 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
13006 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
13010 processing_template_decl
++;
13014 tree arg1
= TREE_VALUE (args1
);
13015 tree arg2
= TREE_VALUE (args2
);
13016 int deduce1
, deduce2
;
13020 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
13021 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13023 /* When both arguments are pack expansions, we need only
13024 unify the patterns themselves. */
13025 arg1
= PACK_EXPANSION_PATTERN (arg1
);
13026 arg2
= PACK_EXPANSION_PATTERN (arg2
);
13028 /* This is the last comparison we need to do. */
13032 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
13034 arg1
= TREE_TYPE (arg1
);
13035 quals1
= cp_type_quals (arg1
);
13038 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
13040 arg2
= TREE_TYPE (arg2
);
13041 quals2
= cp_type_quals (arg2
);
13044 if ((quals1
< 0) != (quals2
< 0))
13046 /* Only of the args is a reference, see if we should apply
13047 array/function pointer decay to it. This is not part of
13048 DR214, but is, IMHO, consistent with the deduction rules
13049 for the function call itself, and with our earlier
13050 implementation of the underspecified partial ordering
13051 rules. (nathan). */
13054 switch (TREE_CODE (arg1
))
13057 arg1
= TREE_TYPE (arg1
);
13059 case FUNCTION_TYPE
:
13060 arg1
= build_pointer_type (arg1
);
13069 switch (TREE_CODE (arg2
))
13072 arg2
= TREE_TYPE (arg2
);
13074 case FUNCTION_TYPE
:
13075 arg2
= build_pointer_type (arg2
);
13084 arg1
= TYPE_MAIN_VARIANT (arg1
);
13085 arg2
= TYPE_MAIN_VARIANT (arg2
);
13087 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
13089 int i
, len2
= list_length (args2
);
13090 tree parmvec
= make_tree_vec (1);
13091 tree argvec
= make_tree_vec (len2
);
13094 /* Setup the parameter vector, which contains only ARG1. */
13095 TREE_VEC_ELT (parmvec
, 0) = arg1
;
13097 /* Setup the argument vector, which contains the remaining
13099 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
13100 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
13102 deduce1
= !unify_pack_expansion (tparms1
, targs1
, parmvec
,
13103 argvec
, UNIFY_ALLOW_NONE
,
13104 /*call_args_p=*/false,
13107 /* We cannot deduce in the other direction, because ARG1 is
13108 a pack expansion but ARG2 is not. */
13111 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13113 int i
, len1
= list_length (args1
);
13114 tree parmvec
= make_tree_vec (1);
13115 tree argvec
= make_tree_vec (len1
);
13118 /* Setup the parameter vector, which contains only ARG1. */
13119 TREE_VEC_ELT (parmvec
, 0) = arg2
;
13121 /* Setup the argument vector, which contains the remaining
13123 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
13124 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
13126 deduce2
= !unify_pack_expansion (tparms2
, targs2
, parmvec
,
13127 argvec
, UNIFY_ALLOW_NONE
,
13128 /*call_args_p=*/false,
13131 /* We cannot deduce in the other direction, because ARG2 is
13132 a pack expansion but ARG1 is not.*/
13138 /* The normal case, where neither argument is a pack
13140 deduce1
= !unify (tparms1
, targs1
, arg1
, arg2
, UNIFY_ALLOW_NONE
);
13141 deduce2
= !unify (tparms2
, targs2
, arg2
, arg1
, UNIFY_ALLOW_NONE
);
13148 if (better1
< 0 && better2
< 0)
13149 /* We've failed to deduce something in either direction.
13150 These must be unordered. */
13153 if (deduce1
&& deduce2
&& quals1
>= 0 && quals2
>= 0)
13155 /* Deduces in both directions, see if quals can
13156 disambiguate. Pretend the worse one failed to deduce. */
13157 if ((quals1
& quals2
) == quals2
)
13159 if ((quals1
& quals2
) == quals1
)
13162 if (deduce1
&& !deduce2
&& !better2
)
13164 if (deduce2
&& !deduce1
&& !better1
)
13167 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
13168 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13169 /* We have already processed all of the arguments in our
13170 handing of the pack expansion type. */
13173 args1
= TREE_CHAIN (args1
);
13174 args2
= TREE_CHAIN (args2
);
13177 processing_template_decl
--;
13179 /* All things being equal, if the next argument is a pack expansion
13180 for one function but not for the other, prefer the
13181 non-variadic function. */
13182 if ((better1
> 0) - (better2
> 0) == 0
13183 && args1
&& TREE_VALUE (args1
)
13184 && args2
&& TREE_VALUE (args2
))
13186 if (TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
)
13187 return TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
? 0 : -1;
13188 else if (TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
)
13192 return (better1
> 0) - (better2
> 0);
13195 /* Determine which of two partial specializations is more specialized.
13197 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13198 to the first partial specialization. The TREE_VALUE is the
13199 innermost set of template parameters for the partial
13200 specialization. PAT2 is similar, but for the second template.
13202 Return 1 if the first partial specialization is more specialized;
13203 -1 if the second is more specialized; 0 if neither is more
13206 See [temp.class.order] for information about determining which of
13207 two templates is more specialized. */
13210 more_specialized_class (tree pat1
, tree pat2
)
13215 bool any_deductions
= false;
13217 tmpl1
= TREE_TYPE (pat1
);
13218 tmpl2
= TREE_TYPE (pat2
);
13220 /* Just like what happens for functions, if we are ordering between
13221 different class template specializations, we may encounter dependent
13222 types in the arguments, and we need our dependency check functions
13223 to behave correctly. */
13224 ++processing_template_decl
;
13225 targs
= get_class_bindings (TREE_VALUE (pat1
),
13226 CLASSTYPE_TI_ARGS (tmpl1
),
13227 CLASSTYPE_TI_ARGS (tmpl2
));
13231 any_deductions
= true;
13234 targs
= get_class_bindings (TREE_VALUE (pat2
),
13235 CLASSTYPE_TI_ARGS (tmpl2
),
13236 CLASSTYPE_TI_ARGS (tmpl1
));
13240 any_deductions
= true;
13242 --processing_template_decl
;
13244 /* In the case of a tie where at least one of the class templates
13245 has a parameter pack at the end, the template with the most
13246 non-packed parameters wins. */
13249 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
13250 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
13252 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
13253 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
13254 int len1
= TREE_VEC_LENGTH (args1
);
13255 int len2
= TREE_VEC_LENGTH (args2
);
13257 /* We don't count the pack expansion at the end. */
13258 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
13260 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
13265 else if (len1
< len2
)
13272 /* Return the template arguments that will produce the function signature
13273 DECL from the function template FN, with the explicit template
13274 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13275 also match. Return NULL_TREE if no satisfactory arguments could be
13279 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
13281 int ntparms
= DECL_NTPARMS (fn
);
13282 tree targs
= make_tree_vec (ntparms
);
13284 tree decl_arg_types
;
13286 /* Substitute the explicit template arguments into the type of DECL.
13287 The call to fn_type_unification will handle substitution into the
13289 decl_type
= TREE_TYPE (decl
);
13290 if (explicit_args
&& uses_template_parms (decl_type
))
13293 tree converted_args
;
13295 if (DECL_TEMPLATE_INFO (decl
))
13296 tmpl
= DECL_TI_TEMPLATE (decl
);
13298 /* We can get here for some invalid specializations. */
13302 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
13303 explicit_args
, NULL_TREE
,
13305 /*require_all_args=*/false,
13306 /*use_default_args=*/false);
13307 if (converted_args
== error_mark_node
)
13310 decl_type
= tsubst (decl_type
, converted_args
, tf_none
, NULL_TREE
);
13311 if (decl_type
== error_mark_node
)
13315 /* Never do unification on the 'this' parameter. */
13316 decl_arg_types
= skip_artificial_parms_for (decl
,
13317 TYPE_ARG_TYPES (decl_type
));
13319 if (fn_type_unification (fn
, explicit_args
, targs
,
13321 (check_rettype
|| DECL_CONV_FN_P (fn
)
13322 ? TREE_TYPE (decl_type
) : NULL_TREE
),
13323 DEDUCE_EXACT
, LOOKUP_NORMAL
))
13329 /* Return the innermost template arguments that, when applied to a
13330 template specialization whose innermost template parameters are
13331 TPARMS, and whose specialization arguments are PARMS, yield the
13334 For example, suppose we have:
13336 template <class T, class U> struct S {};
13337 template <class T> struct S<T*, int> {};
13339 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13340 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13341 int}. The resulting vector will be {double}, indicating that `T'
13342 is bound to `double'. */
13345 get_class_bindings (tree tparms
, tree spec_args
, tree args
)
13347 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
13349 tree innermost_deduced_args
;
13351 innermost_deduced_args
= make_tree_vec (ntparms
);
13352 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
13354 deduced_args
= copy_node (args
);
13355 SET_TMPL_ARGS_LEVEL (deduced_args
,
13356 TMPL_ARGS_DEPTH (deduced_args
),
13357 innermost_deduced_args
);
13360 deduced_args
= innermost_deduced_args
;
13362 if (unify (tparms
, deduced_args
,
13363 INNERMOST_TEMPLATE_ARGS (spec_args
),
13364 INNERMOST_TEMPLATE_ARGS (args
),
13368 for (i
= 0; i
< ntparms
; ++i
)
13369 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
13372 /* Verify that nondeduced template arguments agree with the type
13373 obtained from argument deduction.
13377 struct A { typedef int X; };
13378 template <class T, class U> struct C {};
13379 template <class T> struct C<T, typename T::X> {};
13381 Then with the instantiation `C<A, int>', we can deduce that
13382 `T' is `A' but unify () does not check whether `typename T::X'
13384 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
13385 if (spec_args
== error_mark_node
13386 /* We only need to check the innermost arguments; the other
13387 arguments will always agree. */
13388 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
13389 INNERMOST_TEMPLATE_ARGS (args
)))
13392 return deduced_args
;
13395 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
13396 Return the TREE_LIST node with the most specialized template, if
13397 any. If there is no most specialized template, the error_mark_node
13400 Note that this function does not look at, or modify, the
13401 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
13402 returned is one of the elements of INSTANTIATIONS, callers may
13403 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
13404 and retrieve it from the value returned. */
13407 most_specialized_instantiation (tree templates
)
13411 ++processing_template_decl
;
13414 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
13418 if (get_bindings (TREE_VALUE (champ
),
13419 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
13420 NULL_TREE
, /*check_ret=*/false))
13423 if (get_bindings (TREE_VALUE (fn
),
13424 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
13425 NULL_TREE
, /*check_ret=*/false))
13432 /* Equally specialized, move to next function. If there
13433 is no next function, nothing's most specialized. */
13434 fn
= TREE_CHAIN (fn
);
13442 /* Now verify that champ is better than everything earlier in the
13443 instantiation list. */
13444 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
13445 if (get_bindings (TREE_VALUE (champ
),
13446 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
13447 NULL_TREE
, /*check_ret=*/false)
13448 || !get_bindings (TREE_VALUE (fn
),
13449 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
13450 NULL_TREE
, /*check_ret=*/false))
13456 processing_template_decl
--;
13459 return error_mark_node
;
13464 /* If DECL is a specialization of some template, return the most
13465 general such template. Otherwise, returns NULL_TREE.
13467 For example, given:
13469 template <class T> struct S { template <class U> void f(U); };
13471 if TMPL is `template <class U> void S<int>::f(U)' this will return
13472 the full template. This function will not trace past partial
13473 specializations, however. For example, given in addition:
13475 template <class T> struct S<T*> { template <class U> void f(U); };
13477 if TMPL is `template <class U> void S<int*>::f(U)' this will return
13478 `template <class T> template <class U> S<T*>::f(U)'. */
13481 most_general_template (tree decl
)
13483 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
13484 an immediate specialization. */
13485 if (TREE_CODE (decl
) == FUNCTION_DECL
)
13487 if (DECL_TEMPLATE_INFO (decl
)) {
13488 decl
= DECL_TI_TEMPLATE (decl
);
13490 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
13491 template friend. */
13492 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
13498 /* Look for more and more general templates. */
13499 while (DECL_TEMPLATE_INFO (decl
))
13501 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
13502 (See cp-tree.h for details.) */
13503 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
13506 if (CLASS_TYPE_P (TREE_TYPE (decl
))
13507 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
13510 /* Stop if we run into an explicitly specialized class template. */
13511 if (!DECL_NAMESPACE_SCOPE_P (decl
)
13512 && DECL_CONTEXT (decl
)
13513 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
13516 decl
= DECL_TI_TEMPLATE (decl
);
13522 /* Return the most specialized of the class template partial
13523 specializations of TMPL which can produce TYPE, a specialization of
13524 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
13525 a _TYPE node corresponding to the partial specialization, while the
13526 TREE_PURPOSE is the set of template arguments that must be
13527 substituted into the TREE_TYPE in order to generate TYPE.
13529 If the choice of partial specialization is ambiguous, a diagnostic
13530 is issued, and the error_mark_node is returned. If there are no
13531 partial specializations of TMPL matching TYPE, then NULL_TREE is
13535 most_specialized_class (tree type
, tree tmpl
)
13537 tree list
= NULL_TREE
;
13544 tmpl
= most_general_template (tmpl
);
13545 args
= CLASSTYPE_TI_ARGS (type
);
13546 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
13548 tree partial_spec_args
;
13551 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
13552 spec_args
= get_class_bindings (TREE_VALUE (t
),
13557 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
13558 TREE_TYPE (list
) = TREE_TYPE (t
);
13565 ambiguous_p
= false;
13568 t
= TREE_CHAIN (t
);
13569 for (; t
; t
= TREE_CHAIN (t
))
13571 fate
= more_specialized_class (champ
, t
);
13578 t
= TREE_CHAIN (t
);
13581 ambiguous_p
= true;
13590 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
13592 fate
= more_specialized_class (champ
, t
);
13595 ambiguous_p
= true;
13602 const char *str
= "candidates are:";
13603 error ("ambiguous class template instantiation for %q#T", type
);
13604 for (t
= list
; t
; t
= TREE_CHAIN (t
))
13606 error ("%s %+#T", str
, TREE_TYPE (t
));
13609 return error_mark_node
;
13615 /* Explicitly instantiate DECL. */
13618 do_decl_instantiation (tree decl
, tree storage
)
13620 tree result
= NULL_TREE
;
13623 if (!decl
|| decl
== error_mark_node
)
13624 /* An error occurred, for which grokdeclarator has already issued
13625 an appropriate message. */
13627 else if (! DECL_LANG_SPECIFIC (decl
))
13629 error ("explicit instantiation of non-template %q#D", decl
);
13632 else if (TREE_CODE (decl
) == VAR_DECL
)
13634 /* There is an asymmetry here in the way VAR_DECLs and
13635 FUNCTION_DECLs are handled by grokdeclarator. In the case of
13636 the latter, the DECL we get back will be marked as a
13637 template instantiation, and the appropriate
13638 DECL_TEMPLATE_INFO will be set up. This does not happen for
13639 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
13640 should handle VAR_DECLs as it currently handles
13642 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
13643 if (!result
|| TREE_CODE (result
) != VAR_DECL
)
13645 error ("no matching template for %qD found", decl
);
13648 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
13650 error ("type %qT for explicit instantiation %qD does not match "
13651 "declared type %qT", TREE_TYPE (result
), decl
,
13656 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
13658 error ("explicit instantiation of %q#D", decl
);
13664 /* Check for various error cases. Note that if the explicit
13665 instantiation is valid the RESULT will currently be marked as an
13666 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
13667 until we get here. */
13669 if (DECL_TEMPLATE_SPECIALIZATION (result
))
13671 /* DR 259 [temp.spec].
13673 Both an explicit instantiation and a declaration of an explicit
13674 specialization shall not appear in a program unless the explicit
13675 instantiation follows a declaration of the explicit specialization.
13677 For a given set of template parameters, if an explicit
13678 instantiation of a template appears after a declaration of an
13679 explicit specialization for that template, the explicit
13680 instantiation has no effect. */
13683 else if (DECL_EXPLICIT_INSTANTIATION (result
))
13687 No program shall explicitly instantiate any template more
13690 We check DECL_NOT_REALLY_EXTERN so as not to complain when
13691 the first instantiation was `extern' and the second is not,
13692 and EXTERN_P for the opposite case. */
13693 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
13694 pedwarn ("duplicate explicit instantiation of %q#D", result
);
13695 /* If an "extern" explicit instantiation follows an ordinary
13696 explicit instantiation, the template is instantiated. */
13700 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
13702 error ("no matching template for %qD found", result
);
13705 else if (!DECL_TEMPLATE_INFO (result
))
13707 pedwarn ("explicit instantiation of non-template %q#D", result
);
13711 if (storage
== NULL_TREE
)
13713 else if (storage
== ridpointers
[(int) RID_EXTERN
])
13715 if (pedantic
&& !in_system_header
)
13716 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
13721 error ("storage class %qD applied to template instantiation", storage
);
13723 check_explicit_instantiation_namespace (result
);
13724 mark_decl_instantiated (result
, extern_p
);
13726 instantiate_decl (result
, /*defer_ok=*/1,
13727 /*expl_inst_class_mem_p=*/false);
13731 mark_class_instantiated (tree t
, int extern_p
)
13733 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
13734 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
13735 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
13736 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
13739 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
13740 rest_of_type_compilation (t
, 1);
13744 /* Called from do_type_instantiation through binding_table_foreach to
13745 do recursive instantiation for the type bound in ENTRY. */
13747 bt_instantiate_type_proc (binding_entry entry
, void *data
)
13749 tree storage
= *(tree
*) data
;
13751 if (IS_AGGR_TYPE (entry
->type
)
13752 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
13753 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
13756 /* Called from do_type_instantiation to instantiate a member
13757 (a member function or a static member variable) of an
13758 explicitly instantiated class template. */
13760 instantiate_class_member (tree decl
, int extern_p
)
13762 mark_decl_instantiated (decl
, extern_p
);
13764 instantiate_decl (decl
, /*defer_ok=*/1,
13765 /*expl_inst_class_mem_p=*/true);
13768 /* Perform an explicit instantiation of template class T. STORAGE, if
13769 non-null, is the RID for extern, inline or static. COMPLAIN is
13770 nonzero if this is called from the parser, zero if called recursively,
13771 since the standard is unclear (as detailed below). */
13774 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
13779 int previous_instantiation_extern_p
= 0;
13781 if (TREE_CODE (t
) == TYPE_DECL
)
13784 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
13786 error ("explicit instantiation of non-template type %qT", t
);
13792 if (!COMPLETE_TYPE_P (t
))
13794 if (complain
& tf_error
)
13795 error ("explicit instantiation of %q#T before definition of template",
13800 if (storage
!= NULL_TREE
)
13802 if (pedantic
&& !in_system_header
)
13803 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
13806 if (storage
== ridpointers
[(int) RID_INLINE
])
13808 else if (storage
== ridpointers
[(int) RID_EXTERN
])
13810 else if (storage
== ridpointers
[(int) RID_STATIC
])
13814 error ("storage class %qD applied to template instantiation",
13820 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
13822 /* DR 259 [temp.spec].
13824 Both an explicit instantiation and a declaration of an explicit
13825 specialization shall not appear in a program unless the explicit
13826 instantiation follows a declaration of the explicit specialization.
13828 For a given set of template parameters, if an explicit
13829 instantiation of a template appears after a declaration of an
13830 explicit specialization for that template, the explicit
13831 instantiation has no effect. */
13834 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
13838 No program shall explicitly instantiate any template more
13841 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
13842 instantiation was `extern'. If EXTERN_P then the second is.
13843 These cases are OK. */
13844 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
13846 if (!previous_instantiation_extern_p
&& !extern_p
13847 && (complain
& tf_error
))
13848 pedwarn ("duplicate explicit instantiation of %q#T", t
);
13850 /* If we've already instantiated the template, just return now. */
13851 if (!CLASSTYPE_INTERFACE_ONLY (t
))
13855 check_explicit_instantiation_namespace (TYPE_NAME (t
));
13856 mark_class_instantiated (t
, extern_p
);
13864 /* In contrast to implicit instantiation, where only the
13865 declarations, and not the definitions, of members are
13866 instantiated, we have here:
13870 The explicit instantiation of a class template specialization
13871 implies the instantiation of all of its members not
13872 previously explicitly specialized in the translation unit
13873 containing the explicit instantiation.
13875 Of course, we can't instantiate member template classes, since
13876 we don't have any arguments for them. Note that the standard
13877 is unclear on whether the instantiation of the members are
13878 *explicit* instantiations or not. However, the most natural
13879 interpretation is that it should be an explicit instantiation. */
13882 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
13883 if (TREE_CODE (tmp
) == FUNCTION_DECL
13884 && DECL_TEMPLATE_INSTANTIATION (tmp
))
13885 instantiate_class_member (tmp
, extern_p
);
13887 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
13888 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
13889 instantiate_class_member (tmp
, extern_p
);
13891 if (CLASSTYPE_NESTED_UTDS (t
))
13892 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
13893 bt_instantiate_type_proc
, &storage
);
13897 /* Given a function DECL, which is a specialization of TMPL, modify
13898 DECL to be a re-instantiation of TMPL with the same template
13899 arguments. TMPL should be the template into which tsubst'ing
13900 should occur for DECL, not the most general template.
13902 One reason for doing this is a scenario like this:
13905 void f(const T&, int i);
13907 void g() { f(3, 7); }
13910 void f(const T& t, const int i) { }
13912 Note that when the template is first instantiated, with
13913 instantiate_template, the resulting DECL will have no name for the
13914 first parameter, and the wrong type for the second. So, when we go
13915 to instantiate the DECL, we regenerate it. */
13918 regenerate_decl_from_template (tree decl
, tree tmpl
)
13920 /* The arguments used to instantiate DECL, from the most general
13925 args
= DECL_TI_ARGS (decl
);
13926 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
13928 /* Make sure that we can see identifiers, and compute access
13930 push_access_scope (decl
);
13932 if (TREE_CODE (decl
) == FUNCTION_DECL
)
13940 args_depth
= TMPL_ARGS_DEPTH (args
);
13941 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
13942 if (args_depth
> parms_depth
)
13943 args
= get_innermost_template_args (args
, parms_depth
);
13945 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
13946 args
, tf_error
, NULL_TREE
);
13948 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
13951 /* Merge parameter declarations. */
13952 decl_parm
= skip_artificial_parms_for (decl
,
13953 DECL_ARGUMENTS (decl
));
13955 = skip_artificial_parms_for (code_pattern
,
13956 DECL_ARGUMENTS (code_pattern
));
13957 while (decl_parm
&& !FUNCTION_PARAMETER_PACK_P (pattern_parm
))
13962 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
13963 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
13964 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
13966 parm_type
= type_decays_to (parm_type
);
13967 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
13968 TREE_TYPE (decl_parm
) = parm_type
;
13969 attributes
= DECL_ATTRIBUTES (pattern_parm
);
13970 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
13972 DECL_ATTRIBUTES (decl_parm
) = attributes
;
13973 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
13975 decl_parm
= TREE_CHAIN (decl_parm
);
13976 pattern_parm
= TREE_CHAIN (pattern_parm
);
13978 /* Merge any parameters that match with the function parameter
13980 if (pattern_parm
&& FUNCTION_PARAMETER_PACK_P (pattern_parm
))
13983 tree expanded_types
;
13984 /* Expand the TYPE_PACK_EXPANSION that provides the types for
13985 the parameters in this function parameter pack. */
13986 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
13987 args
, tf_error
, NULL_TREE
);
13988 len
= TREE_VEC_LENGTH (expanded_types
);
13989 for (i
= 0; i
< len
; i
++)
13994 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
13995 /* Rename the parameter to include the index. */
13996 DECL_NAME (decl_parm
) =
13997 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
13998 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
13999 parm_type
= type_decays_to (parm_type
);
14000 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
14001 TREE_TYPE (decl_parm
) = parm_type
;
14002 attributes
= DECL_ATTRIBUTES (pattern_parm
);
14003 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
14005 DECL_ATTRIBUTES (decl_parm
) = attributes
;
14006 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
14008 decl_parm
= TREE_CHAIN (decl_parm
);
14011 /* Merge additional specifiers from the CODE_PATTERN. */
14012 if (DECL_DECLARED_INLINE_P (code_pattern
)
14013 && !DECL_DECLARED_INLINE_P (decl
))
14014 DECL_DECLARED_INLINE_P (decl
) = 1;
14015 if (DECL_INLINE (code_pattern
) && !DECL_INLINE (decl
))
14016 DECL_INLINE (decl
) = 1;
14018 else if (TREE_CODE (decl
) == VAR_DECL
)
14019 DECL_INITIAL (decl
) =
14020 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
14021 tf_error
, DECL_TI_TEMPLATE (decl
),
14022 /*integral_constant_expression_p=*/false);
14024 gcc_unreachable ();
14026 pop_access_scope (decl
);
14029 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14030 substituted to get DECL. */
14033 template_for_substitution (tree decl
)
14035 tree tmpl
= DECL_TI_TEMPLATE (decl
);
14037 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14038 for the instantiation. This is not always the most general
14039 template. Consider, for example:
14042 struct S { template <class U> void f();
14043 template <> void f<int>(); };
14045 and an instantiation of S<double>::f<int>. We want TD to be the
14046 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14047 while (/* An instantiation cannot have a definition, so we need a
14048 more general template. */
14049 DECL_TEMPLATE_INSTANTIATION (tmpl
)
14050 /* We must also deal with friend templates. Given:
14052 template <class T> struct S {
14053 template <class U> friend void f() {};
14056 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14057 so far as the language is concerned, but that's still
14058 where we get the pattern for the instantiation from. On
14059 other hand, if the definition comes outside the class, say:
14061 template <class T> struct S {
14062 template <class U> friend void f();
14064 template <class U> friend void f() {}
14066 we don't need to look any further. That's what the check for
14067 DECL_INITIAL is for. */
14068 || (TREE_CODE (decl
) == FUNCTION_DECL
14069 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
14070 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
14072 /* The present template, TD, should not be a definition. If it
14073 were a definition, we should be using it! Note that we
14074 cannot restructure the loop to just keep going until we find
14075 a template with a definition, since that might go too far if
14076 a specialization was declared, but not defined. */
14077 gcc_assert (TREE_CODE (decl
) != VAR_DECL
14078 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
14080 /* Fetch the more general template. */
14081 tmpl
= DECL_TI_TEMPLATE (tmpl
);
14087 /* Produce the definition of D, a _DECL generated from a template. If
14088 DEFER_OK is nonzero, then we don't have to actually do the
14089 instantiation now; we just have to do it sometime. Normally it is
14090 an error if this is an explicit instantiation but D is undefined.
14091 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14092 explicitly instantiated class template. */
14095 instantiate_decl (tree d
, int defer_ok
,
14096 bool expl_inst_class_mem_p
)
14098 tree tmpl
= DECL_TI_TEMPLATE (d
);
14105 bool pattern_defined
;
14107 location_t saved_loc
= input_location
;
14108 int saved_in_system_header
= in_system_header
;
14111 /* This function should only be used to instantiate templates for
14112 functions and static member variables. */
14113 gcc_assert (TREE_CODE (d
) == FUNCTION_DECL
14114 || TREE_CODE (d
) == VAR_DECL
);
14116 /* Variables are never deferred; if instantiation is required, they
14117 are instantiated right away. That allows for better code in the
14118 case that an expression refers to the value of the variable --
14119 if the variable has a constant value the referring expression can
14120 take advantage of that fact. */
14121 if (TREE_CODE (d
) == VAR_DECL
)
14124 /* Don't instantiate cloned functions. Instead, instantiate the
14125 functions they cloned. */
14126 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
14127 d
= DECL_CLONED_FUNCTION (d
);
14129 if (DECL_TEMPLATE_INSTANTIATED (d
))
14130 /* D has already been instantiated. It might seem reasonable to
14131 check whether or not D is an explicit instantiation, and, if so,
14132 stop here. But when an explicit instantiation is deferred
14133 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14134 is set, even though we still need to do the instantiation. */
14137 /* If we already have a specialization of this declaration, then
14138 there's no reason to instantiate it. Note that
14139 retrieve_specialization gives us both instantiations and
14140 specializations, so we must explicitly check
14141 DECL_TEMPLATE_SPECIALIZATION. */
14142 gen_tmpl
= most_general_template (tmpl
);
14143 gen_args
= DECL_TI_ARGS (d
);
14144 spec
= retrieve_specialization (gen_tmpl
, gen_args
,
14145 /*class_specializations_p=*/false);
14146 if (spec
!= NULL_TREE
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
14149 /* This needs to happen before any tsubsting. */
14150 if (! push_tinst_level (d
))
14153 timevar_push (TV_PARSE
);
14155 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14156 for the instantiation. */
14157 td
= template_for_substitution (d
);
14158 code_pattern
= DECL_TEMPLATE_RESULT (td
);
14160 /* We should never be trying to instantiate a member of a class
14161 template or partial specialization. */
14162 gcc_assert (d
!= code_pattern
);
14164 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
14165 || DECL_TEMPLATE_SPECIALIZATION (td
))
14166 /* In the case of a friend template whose definition is provided
14167 outside the class, we may have too many arguments. Drop the
14168 ones we don't need. The same is true for specializations. */
14169 args
= get_innermost_template_args
14170 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
14174 if (TREE_CODE (d
) == FUNCTION_DECL
)
14175 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
);
14177 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
14179 /* We may be in the middle of deferred access check. Disable it now. */
14180 push_deferring_access_checks (dk_no_deferred
);
14182 /* Unless an explicit instantiation directive has already determined
14183 the linkage of D, remember that a definition is available for
14185 if (pattern_defined
14186 && !DECL_INTERFACE_KNOWN (d
)
14187 && !DECL_NOT_REALLY_EXTERN (d
))
14188 mark_definable (d
);
14190 input_location
= DECL_SOURCE_LOCATION (d
);
14191 in_system_header
= DECL_IN_SYSTEM_HEADER (d
);
14193 /* If D is a member of an explicitly instantiated class template,
14194 and no definition is available, treat it like an implicit
14196 if (!pattern_defined
&& expl_inst_class_mem_p
14197 && DECL_EXPLICIT_INSTANTIATION (d
))
14199 DECL_NOT_REALLY_EXTERN (d
) = 0;
14200 DECL_INTERFACE_KNOWN (d
) = 0;
14201 SET_DECL_IMPLICIT_INSTANTIATION (d
);
14206 /* Recheck the substitutions to obtain any warning messages
14207 about ignoring cv qualifiers. */
14208 tree gen
= DECL_TEMPLATE_RESULT (gen_tmpl
);
14209 tree type
= TREE_TYPE (gen
);
14211 /* Make sure that we can see identifiers, and compute access
14212 correctly. D is already the target FUNCTION_DECL with the
14214 push_access_scope (d
);
14216 if (TREE_CODE (gen
) == FUNCTION_DECL
)
14218 tsubst (DECL_ARGUMENTS (gen
), gen_args
, tf_warning_or_error
, d
);
14219 tsubst_exception_specification (type
, gen_args
, tf_warning_or_error
,
14221 /* Don't simply tsubst the function type, as that will give
14222 duplicate warnings about poor parameter qualifications.
14223 The function arguments are the same as the decl_arguments
14224 without the top level cv qualifiers. */
14225 type
= TREE_TYPE (type
);
14227 tsubst (type
, gen_args
, tf_warning_or_error
, d
);
14229 pop_access_scope (d
);
14232 /* Check to see whether we know that this template will be
14233 instantiated in some other file, as with "extern template"
14235 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
14236 /* In general, we do not instantiate such templates... */
14238 /* ... but we instantiate inline functions so that we can inline
14240 && ! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
))
14241 /* ... we instantiate static data members whose values are
14242 needed in integral constant expressions. */
14243 && ! (TREE_CODE (d
) == VAR_DECL
14244 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d
)))
14246 /* Defer all other templates, unless we have been explicitly
14247 forbidden from doing so. */
14248 if (/* If there is no definition, we cannot instantiate the
14251 /* If it's OK to postpone instantiation, do so. */
14253 /* If this is a static data member that will be defined
14254 elsewhere, we don't want to instantiate the entire data
14255 member, but we do want to instantiate the initializer so that
14256 we can substitute that elsewhere. */
14257 || (external_p
&& TREE_CODE (d
) == VAR_DECL
))
14259 /* The definition of the static data member is now required so
14260 we must substitute the initializer. */
14261 if (TREE_CODE (d
) == VAR_DECL
14262 && !DECL_INITIAL (d
)
14263 && DECL_INITIAL (code_pattern
))
14268 ns
= decl_namespace_context (d
);
14269 push_nested_namespace (ns
);
14270 push_nested_class (DECL_CONTEXT (d
));
14271 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
14273 tf_warning_or_error
, NULL_TREE
,
14274 /*integral_constant_expression_p=*/false);
14275 cp_finish_decl (d
, init
, /*init_const_expr_p=*/false,
14276 /*asmspec_tree=*/NULL_TREE
,
14277 LOOKUP_ONLYCONVERTING
);
14278 pop_nested_class ();
14279 pop_nested_namespace (ns
);
14282 /* We restore the source position here because it's used by
14283 add_pending_template. */
14284 input_location
= saved_loc
;
14286 if (at_eof
&& !pattern_defined
14287 && DECL_EXPLICIT_INSTANTIATION (d
))
14290 The definition of a non-exported function template, a
14291 non-exported member function template, or a non-exported
14292 member function or static data member of a class template
14293 shall be present in every translation unit in which it is
14294 explicitly instantiated. */
14296 ("explicit instantiation of %qD but no definition available", d
);
14298 /* ??? Historically, we have instantiated inline functions, even
14299 when marked as "extern template". */
14300 if (!(external_p
&& TREE_CODE (d
) == VAR_DECL
))
14301 add_pending_template (d
);
14304 /* Tell the repository that D is available in this translation unit
14305 -- and see if it is supposed to be instantiated here. */
14306 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
14308 /* In a PCH file, despite the fact that the repository hasn't
14309 requested instantiation in the PCH it is still possible that
14310 an instantiation will be required in a file that includes the
14313 add_pending_template (d
);
14314 /* Instantiate inline functions so that the inliner can do its
14315 job, even though we'll not be emitting a copy of this
14317 if (!(TREE_CODE (d
) == FUNCTION_DECL
14318 && flag_inline_trees
14319 && DECL_DECLARED_INLINE_P (d
)))
14323 need_push
= !cfun
|| !global_bindings_p ();
14325 push_to_top_level ();
14327 /* Mark D as instantiated so that recursive calls to
14328 instantiate_decl do not try to instantiate it again. */
14329 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
14331 /* Regenerate the declaration in case the template has been modified
14332 by a subsequent redeclaration. */
14333 regenerate_decl_from_template (d
, td
);
14335 /* We already set the file and line above. Reset them now in case
14336 they changed as a result of calling regenerate_decl_from_template. */
14337 input_location
= DECL_SOURCE_LOCATION (d
);
14339 if (TREE_CODE (d
) == VAR_DECL
)
14343 /* Clear out DECL_RTL; whatever was there before may not be right
14344 since we've reset the type of the declaration. */
14345 SET_DECL_RTL (d
, NULL_RTX
);
14346 DECL_IN_AGGR_P (d
) = 0;
14348 /* The initializer is placed in DECL_INITIAL by
14349 regenerate_decl_from_template. Pull it out so that
14350 finish_decl can process it. */
14351 init
= DECL_INITIAL (d
);
14352 DECL_INITIAL (d
) = NULL_TREE
;
14353 DECL_INITIALIZED_P (d
) = 0;
14355 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
14356 initializer. That function will defer actual emission until
14357 we have a chance to determine linkage. */
14358 DECL_EXTERNAL (d
) = 0;
14360 /* Enter the scope of D so that access-checking works correctly. */
14361 push_nested_class (DECL_CONTEXT (d
));
14362 finish_decl (d
, init
, NULL_TREE
);
14363 pop_nested_class ();
14365 else if (TREE_CODE (d
) == FUNCTION_DECL
)
14367 htab_t saved_local_specializations
;
14372 /* Save away the current list, in case we are instantiating one
14373 template from within the body of another. */
14374 saved_local_specializations
= local_specializations
;
14376 /* Set up the list of local specializations. */
14377 local_specializations
= htab_create (37,
14378 hash_local_specialization
,
14379 eq_local_specializations
,
14382 /* Set up context. */
14383 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
14385 /* Create substitution entries for the parameters. */
14386 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
14387 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
14388 spec_parm
= DECL_ARGUMENTS (d
);
14389 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
14391 register_local_specialization (spec_parm
, tmpl_parm
);
14392 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
14393 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
14395 while (tmpl_parm
&& !FUNCTION_PARAMETER_PACK_P (tmpl_parm
))
14397 register_local_specialization (spec_parm
, tmpl_parm
);
14398 tmpl_parm
= TREE_CHAIN (tmpl_parm
);
14399 spec_parm
= TREE_CHAIN (spec_parm
);
14401 if (tmpl_parm
&& FUNCTION_PARAMETER_PACK_P (tmpl_parm
))
14403 /* Collect all of the extra "packed" parameters into an
14407 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
14408 tree argtypepack
= make_node (TYPE_ARGUMENT_PACK
);
14412 /* Count how many parameters remain. */
14413 for (t
= spec_parm
; t
; t
= TREE_CHAIN (t
))
14416 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
14417 parmvec
= make_tree_vec (len
);
14418 parmtypevec
= make_tree_vec (len
);
14419 for(i
= 0; i
< len
; i
++, spec_parm
= TREE_CHAIN (spec_parm
))
14421 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
14422 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
14425 /* Build the argument packs. */
14426 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
14427 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
14428 TREE_TYPE (argpack
) = argtypepack
;
14430 /* Register the (value) argument pack as a specialization of
14431 TMPL_PARM, then move on. */
14432 register_local_specialization (argpack
, tmpl_parm
);
14433 tmpl_parm
= TREE_CHAIN (tmpl_parm
);
14435 gcc_assert (!spec_parm
);
14437 /* Substitute into the body of the function. */
14438 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
14439 tf_warning_or_error
, tmpl
,
14440 /*integral_constant_expression_p=*/false);
14442 /* We don't need the local specializations any more. */
14443 htab_delete (local_specializations
);
14444 local_specializations
= saved_local_specializations
;
14446 /* Finish the function. */
14447 d
= finish_function (0);
14448 expand_or_defer_fn (d
);
14451 /* We're not deferring instantiation any more. */
14452 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
14455 pop_from_top_level ();
14458 input_location
= saved_loc
;
14459 in_system_header
= saved_in_system_header
;
14460 pop_deferring_access_checks ();
14461 pop_tinst_level ();
14463 timevar_pop (TV_PARSE
);
14468 /* Run through the list of templates that we wish we could
14469 instantiate, and instantiate any we can. RETRIES is the
14470 number of times we retry pending template instantiation. */
14473 instantiate_pending_templates (int retries
)
14476 tree last
= NULL_TREE
;
14478 location_t saved_loc
= input_location
;
14479 int saved_in_system_header
= in_system_header
;
14481 /* Instantiating templates may trigger vtable generation. This in turn
14482 may require further template instantiations. We place a limit here
14483 to avoid infinite loop. */
14484 if (pending_templates
&& retries
>= max_tinst_depth
)
14486 tree decl
= TREE_VALUE (pending_templates
);
14488 error ("template instantiation depth exceeds maximum of %d"
14489 " instantiating %q+D, possibly from virtual table generation"
14490 " (use -ftemplate-depth-NN to increase the maximum)",
14491 max_tinst_depth
, decl
);
14492 if (TREE_CODE (decl
) == FUNCTION_DECL
)
14493 /* Pretend that we defined it. */
14494 DECL_INITIAL (decl
) = error_mark_node
;
14502 t
= &pending_templates
;
14505 tree instantiation
= TREE_VALUE (*t
);
14507 reopen_tinst_level (TREE_PURPOSE (*t
));
14509 if (TYPE_P (instantiation
))
14513 if (!COMPLETE_TYPE_P (instantiation
))
14515 instantiate_class_template (instantiation
);
14516 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
14517 for (fn
= TYPE_METHODS (instantiation
);
14519 fn
= TREE_CHAIN (fn
))
14520 if (! DECL_ARTIFICIAL (fn
))
14521 instantiate_decl (fn
,
14523 /*expl_inst_class_mem_p=*/false);
14524 if (COMPLETE_TYPE_P (instantiation
))
14528 if (COMPLETE_TYPE_P (instantiation
))
14529 /* If INSTANTIATION has been instantiated, then we don't
14530 need to consider it again in the future. */
14531 *t
= TREE_CHAIN (*t
);
14535 t
= &TREE_CHAIN (*t
);
14540 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
14541 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
14544 = instantiate_decl (instantiation
,
14546 /*expl_inst_class_mem_p=*/false);
14547 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
14551 if (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
14552 || DECL_TEMPLATE_INSTANTIATED (instantiation
))
14553 /* If INSTANTIATION has been instantiated, then we don't
14554 need to consider it again in the future. */
14555 *t
= TREE_CHAIN (*t
);
14559 t
= &TREE_CHAIN (*t
);
14563 current_tinst_level
= NULL_TREE
;
14565 last_pending_template
= last
;
14567 while (reconsider
);
14569 input_location
= saved_loc
;
14570 in_system_header
= saved_in_system_header
;
14573 /* Substitute ARGVEC into T, which is a list of initializers for
14574 either base class or a non-static data member. The TREE_PURPOSEs
14575 are DECLs, and the TREE_VALUEs are the initializer values. Used by
14576 instantiate_decl. */
14579 tsubst_initializer_list (tree t
, tree argvec
)
14581 tree inits
= NULL_TREE
;
14583 for (; t
; t
= TREE_CHAIN (t
))
14587 tree expanded_bases
= NULL_TREE
;
14588 tree expanded_arguments
= NULL_TREE
;
14591 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
14596 /* Expand the base class expansion type into separate base
14598 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
14599 tf_warning_or_error
,
14601 if (expanded_bases
== error_mark_node
)
14604 /* We'll be building separate TREE_LISTs of arguments for
14606 len
= TREE_VEC_LENGTH (expanded_bases
);
14607 expanded_arguments
= make_tree_vec (len
);
14608 for (i
= 0; i
< len
; i
++)
14609 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
14611 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
14612 expand each argument in the TREE_VALUE of t. */
14613 expr
= make_node (EXPR_PACK_EXPANSION
);
14614 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
14615 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
14617 /* Substitute parameter packs into each argument in the
14619 in_base_initializer
= 1;
14620 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
14622 tree expanded_exprs
;
14624 /* Expand the argument. */
14625 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
14626 expanded_exprs
= tsubst_pack_expansion (expr
, argvec
,
14627 tf_warning_or_error
,
14630 /* Prepend each of the expanded expressions to the
14631 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
14632 for (i
= 0; i
< len
; i
++)
14634 TREE_VEC_ELT (expanded_arguments
, i
) =
14635 tree_cons (NULL_TREE
, TREE_VEC_ELT (expanded_exprs
, i
),
14636 TREE_VEC_ELT (expanded_arguments
, i
));
14639 in_base_initializer
= 0;
14641 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
14642 since we built them backwards. */
14643 for (i
= 0; i
< len
; i
++)
14645 TREE_VEC_ELT (expanded_arguments
, i
) =
14646 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
14650 for (i
= 0; i
< len
; ++i
)
14652 if (expanded_bases
)
14654 decl
= TREE_VEC_ELT (expanded_bases
, i
);
14655 decl
= expand_member_init (decl
);
14656 init
= TREE_VEC_ELT (expanded_arguments
, i
);
14660 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
14661 tf_warning_or_error
, NULL_TREE
);
14663 decl
= expand_member_init (decl
);
14664 if (decl
&& !DECL_P (decl
))
14665 in_base_initializer
= 1;
14667 init
= tsubst_expr (TREE_VALUE (t
), argvec
,
14668 tf_warning_or_error
, NULL_TREE
,
14669 /*integral_constant_expression_p=*/false);
14670 in_base_initializer
= 0;
14675 init
= build_tree_list (decl
, init
);
14676 TREE_CHAIN (init
) = inits
;
14684 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
14687 set_current_access_from_decl (tree decl
)
14689 if (TREE_PRIVATE (decl
))
14690 current_access_specifier
= access_private_node
;
14691 else if (TREE_PROTECTED (decl
))
14692 current_access_specifier
= access_protected_node
;
14694 current_access_specifier
= access_public_node
;
14697 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
14698 is the instantiation (which should have been created with
14699 start_enum) and ARGS are the template arguments to use. */
14702 tsubst_enum (tree tag
, tree newtag
, tree args
)
14706 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
14711 decl
= TREE_VALUE (e
);
14712 /* Note that in a template enum, the TREE_VALUE is the
14713 CONST_DECL, not the corresponding INTEGER_CST. */
14714 value
= tsubst_expr (DECL_INITIAL (decl
),
14715 args
, tf_warning_or_error
, NULL_TREE
,
14716 /*integral_constant_expression_p=*/true);
14718 /* Give this enumeration constant the correct access. */
14719 set_current_access_from_decl (decl
);
14721 /* Actually build the enumerator itself. */
14722 build_enumerator (DECL_NAME (decl
), value
, newtag
);
14725 finish_enum (newtag
);
14726 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
14727 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
14730 /* DECL is a FUNCTION_DECL that is a template specialization. Return
14731 its type -- but without substituting the innermost set of template
14732 arguments. So, innermost set of template parameters will appear in
14736 get_mostly_instantiated_function_type (tree decl
)
14744 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
14745 targs
= DECL_TI_ARGS (decl
);
14746 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
14747 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
14749 /* There should be as many levels of arguments as there are levels
14751 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
14753 fn_type
= TREE_TYPE (tmpl
);
14755 if (parm_depth
== 1)
14756 /* No substitution is necessary. */
14760 int i
, save_access_control
;
14763 /* Replace the innermost level of the TARGS with NULL_TREEs to
14764 let tsubst know not to substitute for those parameters. */
14765 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
14766 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
14767 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
14768 TMPL_ARGS_LEVEL (targs
, i
));
14769 SET_TMPL_ARGS_LEVEL (partial_args
,
14770 TMPL_ARGS_DEPTH (targs
),
14771 make_tree_vec (DECL_NTPARMS (tmpl
)));
14773 /* Disable access control as this function is used only during
14775 save_access_control
= flag_access_control
;
14776 flag_access_control
= 0;
14778 ++processing_template_decl
;
14779 /* Now, do the (partial) substitution to figure out the
14780 appropriate function type. */
14781 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
14782 --processing_template_decl
;
14784 /* Substitute into the template parameters to obtain the real
14785 innermost set of parameters. This step is important if the
14786 innermost set of template parameters contains value
14787 parameters whose types depend on outer template parameters. */
14788 TREE_VEC_LENGTH (partial_args
)--;
14789 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
14791 flag_access_control
= save_access_control
;
14797 /* Return truthvalue if we're processing a template different from
14798 the last one involved in diagnostics. */
14800 problematic_instantiation_changed (void)
14802 return last_template_error_tick
!= tinst_level_tick
;
14805 /* Remember current template involved in diagnostics. */
14807 record_last_problematic_instantiation (void)
14809 last_template_error_tick
= tinst_level_tick
;
14813 current_instantiation (void)
14815 return current_tinst_level
;
14818 /* [temp.param] Check that template non-type parm TYPE is of an allowable
14819 type. Return zero for ok, nonzero for disallowed. Issue error and
14820 warning messages under control of COMPLAIN. */
14823 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
14825 if (INTEGRAL_TYPE_P (type
))
14827 else if (POINTER_TYPE_P (type
))
14829 else if (TYPE_PTR_TO_MEMBER_P (type
))
14831 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
14833 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
14836 if (complain
& tf_error
)
14837 error ("%q#T is not a valid type for a template constant parameter", type
);
14841 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
14842 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
14845 dependent_type_p_r (tree type
)
14851 A type is dependent if it is:
14853 -- a template parameter. Template template parameters are types
14854 for us (since TYPE_P holds true for them) so we handle
14856 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
14857 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
14859 /* -- a qualified-id with a nested-name-specifier which contains a
14860 class-name that names a dependent type or whose unqualified-id
14861 names a dependent type. */
14862 if (TREE_CODE (type
) == TYPENAME_TYPE
)
14864 /* -- a cv-qualified type where the cv-unqualified type is
14866 type
= TYPE_MAIN_VARIANT (type
);
14867 /* -- a compound type constructed from any dependent type. */
14868 if (TYPE_PTR_TO_MEMBER_P (type
))
14869 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
14870 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
14872 else if (TREE_CODE (type
) == POINTER_TYPE
14873 || TREE_CODE (type
) == REFERENCE_TYPE
)
14874 return dependent_type_p (TREE_TYPE (type
));
14875 else if (TREE_CODE (type
) == FUNCTION_TYPE
14876 || TREE_CODE (type
) == METHOD_TYPE
)
14880 if (dependent_type_p (TREE_TYPE (type
)))
14882 for (arg_type
= TYPE_ARG_TYPES (type
);
14884 arg_type
= TREE_CHAIN (arg_type
))
14885 if (dependent_type_p (TREE_VALUE (arg_type
)))
14889 /* -- an array type constructed from any dependent type or whose
14890 size is specified by a constant expression that is
14891 value-dependent. */
14892 if (TREE_CODE (type
) == ARRAY_TYPE
)
14894 if (TYPE_DOMAIN (type
)
14895 && ((value_dependent_expression_p
14896 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
14897 || (type_dependent_expression_p
14898 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))))
14900 return dependent_type_p (TREE_TYPE (type
));
14903 /* -- a template-id in which either the template name is a template
14905 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
14907 /* ... or any of the template arguments is a dependent type or
14908 an expression that is type-dependent or value-dependent. */
14909 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
14910 && (any_dependent_template_arguments_p
14911 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
14914 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
14915 argument of the `typeof' expression is not type-dependent, then
14916 it should already been have resolved. */
14917 if (TREE_CODE (type
) == TYPEOF_TYPE
14918 || TREE_CODE (type
) == DECLTYPE_TYPE
)
14921 /* A template argument pack is dependent if any of its packed
14923 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
14925 tree args
= ARGUMENT_PACK_ARGS (type
);
14926 int i
, len
= TREE_VEC_LENGTH (args
);
14927 for (i
= 0; i
< len
; ++i
)
14928 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
14932 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
14933 be template parameters. */
14934 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
14937 /* The standard does not specifically mention types that are local
14938 to template functions or local classes, but they should be
14939 considered dependent too. For example:
14941 template <int I> void f() {
14946 The size of `E' cannot be known until the value of `I' has been
14947 determined. Therefore, `E' must be considered dependent. */
14948 scope
= TYPE_CONTEXT (type
);
14949 if (scope
&& TYPE_P (scope
))
14950 return dependent_type_p (scope
);
14951 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
14952 return type_dependent_expression_p (scope
);
14954 /* Other types are non-dependent. */
14958 /* Returns TRUE if TYPE is dependent, in the sense of
14959 [temp.dep.type]. */
14962 dependent_type_p (tree type
)
14964 /* If there are no template parameters in scope, then there can't be
14965 any dependent types. */
14966 if (!processing_template_decl
)
14968 /* If we are not processing a template, then nobody should be
14969 providing us with a dependent type. */
14971 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
);
14975 /* If the type is NULL, we have not computed a type for the entity
14976 in question; in that case, the type is dependent. */
14980 /* Erroneous types can be considered non-dependent. */
14981 if (type
== error_mark_node
)
14984 /* If we have not already computed the appropriate value for TYPE,
14986 if (!TYPE_DEPENDENT_P_VALID (type
))
14988 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
14989 TYPE_DEPENDENT_P_VALID (type
) = 1;
14992 return TYPE_DEPENDENT_P (type
);
14995 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
14998 dependent_scope_ref_p (tree expression
, bool criterion (tree
))
15003 gcc_assert (TREE_CODE (expression
) == SCOPE_REF
);
15005 if (!TYPE_P (TREE_OPERAND (expression
, 0)))
15008 scope
= TREE_OPERAND (expression
, 0);
15009 name
= TREE_OPERAND (expression
, 1);
15013 An id-expression is type-dependent if it contains a
15014 nested-name-specifier that contains a class-name that names a
15016 /* The suggested resolution to Core Issue 2 implies that if the
15017 qualifying type is the current class, then we must peek
15020 && currently_open_class (scope
)
15021 && !criterion (name
))
15023 if (dependent_type_p (scope
))
15029 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15030 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15034 value_dependent_expression_p (tree expression
)
15036 if (!processing_template_decl
)
15039 /* A name declared with a dependent type. */
15040 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
15043 switch (TREE_CODE (expression
))
15045 case IDENTIFIER_NODE
:
15046 /* A name that has not been looked up -- must be dependent. */
15049 case TEMPLATE_PARM_INDEX
:
15050 /* A non-type template parm. */
15054 /* A non-type template parm. */
15055 if (DECL_TEMPLATE_PARM_P (expression
))
15060 /* A constant with integral or enumeration type and is initialized
15061 with an expression that is value-dependent. */
15062 if (DECL_INITIAL (expression
)
15063 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression
))
15064 && value_dependent_expression_p (DECL_INITIAL (expression
)))
15068 case DYNAMIC_CAST_EXPR
:
15069 case STATIC_CAST_EXPR
:
15070 case CONST_CAST_EXPR
:
15071 case REINTERPRET_CAST_EXPR
:
15073 /* These expressions are value-dependent if the type to which
15074 the cast occurs is dependent or the expression being casted
15075 is value-dependent. */
15077 tree type
= TREE_TYPE (expression
);
15079 if (dependent_type_p (type
))
15082 /* A functional cast has a list of operands. */
15083 expression
= TREE_OPERAND (expression
, 0);
15086 /* If there are no operands, it must be an expression such
15087 as "int()". This should not happen for aggregate types
15088 because it would form non-constant expressions. */
15089 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
15094 if (TREE_CODE (expression
) == TREE_LIST
)
15095 return any_value_dependent_elements_p (expression
);
15097 return value_dependent_expression_p (expression
);
15102 /* A `sizeof' expression is value-dependent if the operand is
15103 type-dependent or is a pack expansion. */
15104 expression
= TREE_OPERAND (expression
, 0);
15105 if (PACK_EXPANSION_P (expression
))
15107 else if (TYPE_P (expression
))
15108 return dependent_type_p (expression
);
15109 return type_dependent_expression_p (expression
);
15112 return dependent_scope_ref_p (expression
, value_dependent_expression_p
);
15114 case COMPONENT_REF
:
15115 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
15116 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
15119 /* A CALL_EXPR may appear in a constant expression if it is a
15120 call to a builtin function, e.g., __builtin_constant_p. All
15121 such calls are value-dependent. */
15124 case NONTYPE_ARGUMENT_PACK
:
15125 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15126 is value-dependent. */
15128 tree values
= ARGUMENT_PACK_ARGS (expression
);
15129 int i
, len
= TREE_VEC_LENGTH (values
);
15131 for (i
= 0; i
< len
; ++i
)
15132 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
15140 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
15141 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
15142 || (type2
? dependent_type_p (type2
) : false));
15146 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
15147 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
15150 /* A constant expression is value-dependent if any subexpression is
15151 value-dependent. */
15152 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
15154 case tcc_reference
:
15156 return (value_dependent_expression_p
15157 (TREE_OPERAND (expression
, 0)));
15159 case tcc_comparison
:
15161 return ((value_dependent_expression_p
15162 (TREE_OPERAND (expression
, 0)))
15163 || (value_dependent_expression_p
15164 (TREE_OPERAND (expression
, 1))));
15166 case tcc_expression
:
15170 for (i
= 0; i
< TREE_OPERAND_LENGTH (expression
); ++i
)
15171 /* In some cases, some of the operands may be missing.
15172 (For example, in the case of PREDECREMENT_EXPR, the
15173 amount to increment by may be missing.) That doesn't
15174 make the expression dependent. */
15175 if (TREE_OPERAND (expression
, i
)
15176 && (value_dependent_expression_p
15177 (TREE_OPERAND (expression
, i
))))
15187 /* The expression is not value-dependent. */
15191 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15192 [temp.dep.expr]. */
15195 type_dependent_expression_p (tree expression
)
15197 if (!processing_template_decl
)
15200 if (expression
== error_mark_node
)
15203 /* An unresolved name is always dependent. */
15204 if (TREE_CODE (expression
) == IDENTIFIER_NODE
15205 || TREE_CODE (expression
) == USING_DECL
)
15208 /* Some expression forms are never type-dependent. */
15209 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
15210 || TREE_CODE (expression
) == SIZEOF_EXPR
15211 || TREE_CODE (expression
) == ALIGNOF_EXPR
15212 || TREE_CODE (expression
) == TRAIT_EXPR
15213 || TREE_CODE (expression
) == TYPEID_EXPR
15214 || TREE_CODE (expression
) == DELETE_EXPR
15215 || TREE_CODE (expression
) == VEC_DELETE_EXPR
15216 || TREE_CODE (expression
) == THROW_EXPR
)
15219 /* The types of these expressions depends only on the type to which
15220 the cast occurs. */
15221 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
15222 || TREE_CODE (expression
) == STATIC_CAST_EXPR
15223 || TREE_CODE (expression
) == CONST_CAST_EXPR
15224 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
15225 || TREE_CODE (expression
) == CAST_EXPR
)
15226 return dependent_type_p (TREE_TYPE (expression
));
15228 /* The types of these expressions depends only on the type created
15229 by the expression. */
15230 if (TREE_CODE (expression
) == NEW_EXPR
15231 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
15233 /* For NEW_EXPR tree nodes created inside a template, either
15234 the object type itself or a TREE_LIST may appear as the
15236 tree type
= TREE_OPERAND (expression
, 1);
15237 if (TREE_CODE (type
) == TREE_LIST
)
15238 /* This is an array type. We need to check array dimensions
15240 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
15241 || value_dependent_expression_p
15242 (TREE_OPERAND (TREE_VALUE (type
), 1));
15244 return dependent_type_p (type
);
15247 if (TREE_CODE (expression
) == SCOPE_REF
15248 && dependent_scope_ref_p (expression
,
15249 type_dependent_expression_p
))
15252 if (TREE_CODE (expression
) == FUNCTION_DECL
15253 && DECL_LANG_SPECIFIC (expression
)
15254 && DECL_TEMPLATE_INFO (expression
)
15255 && (any_dependent_template_arguments_p
15256 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
15259 if (TREE_CODE (expression
) == TEMPLATE_DECL
15260 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
15263 if (TREE_TYPE (expression
) == unknown_type_node
)
15265 if (TREE_CODE (expression
) == ADDR_EXPR
)
15266 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
15267 if (TREE_CODE (expression
) == COMPONENT_REF
15268 || TREE_CODE (expression
) == OFFSET_REF
)
15270 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
15272 expression
= TREE_OPERAND (expression
, 1);
15273 if (TREE_CODE (expression
) == IDENTIFIER_NODE
)
15276 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15277 if (TREE_CODE (expression
) == SCOPE_REF
)
15280 if (TREE_CODE (expression
) == BASELINK
)
15281 expression
= BASELINK_FUNCTIONS (expression
);
15283 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
15285 if (any_dependent_template_arguments_p
15286 (TREE_OPERAND (expression
, 1)))
15288 expression
= TREE_OPERAND (expression
, 0);
15290 gcc_assert (TREE_CODE (expression
) == OVERLOAD
15291 || TREE_CODE (expression
) == FUNCTION_DECL
);
15295 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
15297 expression
= OVL_NEXT (expression
);
15302 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
15304 return (dependent_type_p (TREE_TYPE (expression
)));
15307 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
15308 contains a type-dependent expression. */
15311 any_type_dependent_arguments_p (tree args
)
15315 tree arg
= TREE_VALUE (args
);
15317 if (type_dependent_expression_p (arg
))
15319 args
= TREE_CHAIN (args
);
15324 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
15325 expressions) contains any value-dependent expressions. */
15328 any_value_dependent_elements_p (tree list
)
15330 for (; list
; list
= TREE_CHAIN (list
))
15331 if (value_dependent_expression_p (TREE_VALUE (list
)))
15337 /* Returns TRUE if the ARG (a template argument) is dependent. */
15340 dependent_template_arg_p (tree arg
)
15342 if (!processing_template_decl
)
15345 if (TREE_CODE (arg
) == TEMPLATE_DECL
15346 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
15347 return dependent_template_p (arg
);
15348 else if (ARGUMENT_PACK_P (arg
))
15350 tree args
= ARGUMENT_PACK_ARGS (arg
);
15351 int i
, len
= TREE_VEC_LENGTH (args
);
15352 for (i
= 0; i
< len
; ++i
)
15354 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
15360 else if (TYPE_P (arg
))
15361 return dependent_type_p (arg
);
15363 return (type_dependent_expression_p (arg
)
15364 || value_dependent_expression_p (arg
));
15367 /* Returns true if ARGS (a collection of template arguments) contains
15368 any types that require structural equality testing. */
15371 any_template_arguments_need_structural_equality_p (tree args
)
15378 if (args
== error_mark_node
)
15381 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
15383 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
15384 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
15386 tree arg
= TREE_VEC_ELT (level
, j
);
15387 tree packed_args
= NULL_TREE
;
15390 if (ARGUMENT_PACK_P (arg
))
15392 /* Look inside the argument pack. */
15393 packed_args
= ARGUMENT_PACK_ARGS (arg
);
15394 len
= TREE_VEC_LENGTH (packed_args
);
15397 for (k
= 0; k
< len
; ++k
)
15400 arg
= TREE_VEC_ELT (packed_args
, k
);
15402 if (error_operand_p (arg
))
15404 else if (TREE_CODE (arg
) == TEMPLATE_DECL
15405 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
15407 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
15409 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
15410 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
15419 /* Returns true if ARGS (a collection of template arguments) contains
15420 any dependent arguments. */
15423 any_dependent_template_arguments_p (tree args
)
15430 if (args
== error_mark_node
)
15433 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
15435 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
15436 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
15437 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
15444 /* Returns TRUE if the template TMPL is dependent. */
15447 dependent_template_p (tree tmpl
)
15449 if (TREE_CODE (tmpl
) == OVERLOAD
)
15453 if (dependent_template_p (OVL_FUNCTION (tmpl
)))
15455 tmpl
= OVL_CHAIN (tmpl
);
15460 /* Template template parameters are dependent. */
15461 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
15462 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
15464 /* So are names that have not been looked up. */
15465 if (TREE_CODE (tmpl
) == SCOPE_REF
15466 || TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
15468 /* So are member templates of dependent classes. */
15469 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
15470 return dependent_type_p (DECL_CONTEXT (tmpl
));
15474 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
15477 dependent_template_id_p (tree tmpl
, tree args
)
15479 return (dependent_template_p (tmpl
)
15480 || any_dependent_template_arguments_p (args
));
15483 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
15484 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
15485 no such TYPE can be found. Note that this function peers inside
15486 uninstantiated templates and therefore should be used only in
15487 extremely limited situations. ONLY_CURRENT_P restricts this
15488 peering to the currently open classes hierarchy (which is required
15489 when comparing types). */
15492 resolve_typename_type (tree type
, bool only_current_p
)
15501 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
15503 scope
= TYPE_CONTEXT (type
);
15504 name
= TYPE_IDENTIFIER (type
);
15506 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
15507 it first before we can figure out what NAME refers to. */
15508 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
15509 scope
= resolve_typename_type (scope
, only_current_p
);
15510 /* If we don't know what SCOPE refers to, then we cannot resolve the
15512 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
15514 /* If the SCOPE is a template type parameter, we have no way of
15515 resolving the name. */
15516 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
15518 /* If the SCOPE is not the current instantiation, there's no reason
15519 to look inside it. */
15520 if (only_current_p
&& !currently_open_class (scope
))
15522 /* If SCOPE is a partial instantiation, it will not have a valid
15523 TYPE_FIELDS list, so use the original template. */
15524 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
15525 /* Enter the SCOPE so that name lookup will be resolved as if we
15526 were in the class definition. In particular, SCOPE will no
15527 longer be considered a dependent type. */
15528 pushed_scope
= push_scope (scope
);
15529 /* Look up the declaration. */
15530 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true);
15532 result
= NULL_TREE
;
15534 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
15535 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
15538 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == IDENTIFIER_NODE
15539 && TREE_CODE (decl
) == TYPE_DECL
)
15541 result
= TREE_TYPE (decl
);
15542 if (result
== error_mark_node
)
15543 result
= NULL_TREE
;
15545 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
15546 && DECL_CLASS_TEMPLATE_P (decl
))
15550 /* Obtain the template and the arguments. */
15551 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
15552 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
15553 /* Instantiate the template. */
15554 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
15555 /*entering_scope=*/0,
15556 tf_error
| tf_user
);
15557 if (result
== error_mark_node
)
15558 result
= NULL_TREE
;
15561 /* Leave the SCOPE. */
15563 pop_scope (pushed_scope
);
15565 /* If we failed to resolve it, return the original typename. */
15569 /* If lookup found a typename type, resolve that too. */
15570 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
15572 /* Ill-formed programs can cause infinite recursion here, so we
15573 must catch that. */
15574 TYPENAME_IS_RESOLVING_P (type
) = 1;
15575 result
= resolve_typename_type (result
, only_current_p
);
15576 TYPENAME_IS_RESOLVING_P (type
) = 0;
15579 /* Qualify the resulting type. */
15580 quals
= cp_type_quals (type
);
15582 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
15587 /* EXPR is an expression which is not type-dependent. Return a proxy
15588 for EXPR that can be used to compute the types of larger
15589 expressions containing EXPR. */
15592 build_non_dependent_expr (tree expr
)
15596 /* Preserve null pointer constants so that the type of things like
15597 "p == 0" where "p" is a pointer can be determined. */
15598 if (null_ptr_cst_p (expr
))
15600 /* Preserve OVERLOADs; the functions must be available to resolve
15603 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
15604 inner_expr
= TREE_OPERAND (inner_expr
, 0);
15605 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
15606 inner_expr
= TREE_OPERAND (inner_expr
, 1);
15607 if (is_overloaded_fn (inner_expr
)
15608 || TREE_CODE (inner_expr
) == OFFSET_REF
)
15610 /* There is no need to return a proxy for a variable. */
15611 if (TREE_CODE (expr
) == VAR_DECL
)
15613 /* Preserve string constants; conversions from string constants to
15614 "char *" are allowed, even though normally a "const char *"
15615 cannot be used to initialize a "char *". */
15616 if (TREE_CODE (expr
) == STRING_CST
)
15618 /* Preserve arithmetic constants, as an optimization -- there is no
15619 reason to create a new node. */
15620 if (TREE_CODE (expr
) == INTEGER_CST
|| TREE_CODE (expr
) == REAL_CST
)
15622 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
15623 There is at least one place where we want to know that a
15624 particular expression is a throw-expression: when checking a ?:
15625 expression, there are special rules if the second or third
15626 argument is a throw-expression. */
15627 if (TREE_CODE (expr
) == THROW_EXPR
)
15630 if (TREE_CODE (expr
) == COND_EXPR
)
15631 return build3 (COND_EXPR
,
15633 TREE_OPERAND (expr
, 0),
15634 (TREE_OPERAND (expr
, 1)
15635 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
15636 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
15637 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
15638 if (TREE_CODE (expr
) == COMPOUND_EXPR
15639 && !COMPOUND_EXPR_OVERLOADED (expr
))
15640 return build2 (COMPOUND_EXPR
,
15642 TREE_OPERAND (expr
, 0),
15643 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
15645 /* If the type is unknown, it can't really be non-dependent */
15646 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
15648 /* Otherwise, build a NON_DEPENDENT_EXPR.
15650 REFERENCE_TYPEs are not stripped for expressions in templates
15651 because doing so would play havoc with mangling. Consider, for
15654 template <typename T> void f<T& g>() { g(); }
15656 In the body of "f", the expression for "g" will have
15657 REFERENCE_TYPE, even though the standard says that it should
15658 not. The reason is that we must preserve the syntactic form of
15659 the expression so that mangling (say) "f<g>" inside the body of
15660 "f" works out correctly. Therefore, the REFERENCE_TYPE is
15662 return build1 (NON_DEPENDENT_EXPR
, non_reference (TREE_TYPE (expr
)), expr
);
15665 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
15666 Return a new TREE_LIST with the various arguments replaced with
15667 equivalent non-dependent expressions. */
15670 build_non_dependent_args (tree args
)
15675 new_args
= NULL_TREE
;
15676 for (a
= args
; a
; a
= TREE_CHAIN (a
))
15677 new_args
= tree_cons (NULL_TREE
,
15678 build_non_dependent_expr (TREE_VALUE (a
)),
15680 return nreverse (new_args
);
15683 #include "gt-cp-pt.h"