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, 2007, 2008 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 3, 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 COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Known bugs or deficiencies include:
25 all methods must be provided in header files; can't use a source
26 file that contains only the method templates and "just win". */
30 #include "coretypes.h"
34 #include "pointer-set.h"
38 #include "cp-objcp-common.h"
39 #include "tree-inline.h"
46 #include "tree-iterator.h"
49 /* The type of functions taking a tree, and some additional data, and
51 typedef int (*tree_fn_t
) (tree
, void*);
53 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
54 instantiations have been deferred, either because their definitions
55 were not yet available, or because we were putting off doing the work. */
56 struct pending_template
GTY (()) {
57 struct pending_template
*next
;
58 struct tinst_level
*tinst
;
61 static GTY(()) struct pending_template
*pending_templates
;
62 static GTY(()) struct pending_template
*last_pending_template
;
64 int processing_template_parmlist
;
65 static int template_header_count
;
67 static GTY(()) tree saved_trees
;
68 static VEC(int,heap
) *inline_parm_levels
;
70 static GTY(()) struct tinst_level
*current_tinst_level
;
72 static GTY(()) tree saved_access_scope
;
74 /* Live only within one (recursive) call to tsubst_expr. We use
75 this to pass the statement expression node from the STMT_EXPR
76 to the EXPR_STMT that is its result. */
77 static tree cur_stmt_expr
;
79 /* A map from local variable declarations in the body of the template
80 presently being instantiated to the corresponding instantiated
82 static htab_t local_specializations
;
84 /* Contains canonical template parameter types. The vector is indexed by
85 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
86 TREE_LIST, whose TREE_VALUEs contain the canonical template
87 parameters of various types and levels. */
88 static GTY(()) VEC(tree
,gc
) *canonical_template_parms
;
90 #define UNIFY_ALLOW_NONE 0
91 #define UNIFY_ALLOW_MORE_CV_QUAL 1
92 #define UNIFY_ALLOW_LESS_CV_QUAL 2
93 #define UNIFY_ALLOW_DERIVED 4
94 #define UNIFY_ALLOW_INTEGER 8
95 #define UNIFY_ALLOW_OUTER_LEVEL 16
96 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
97 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
99 static void push_access_scope (tree
);
100 static void pop_access_scope (tree
);
101 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
102 unification_kind_t
, int);
103 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
104 unification_kind_t
, int, bool);
105 static int unify (tree
, tree
, tree
, tree
, int);
106 static void add_pending_template (tree
);
107 static int push_tinst_level (tree
);
108 static void pop_tinst_level (void);
109 static tree
reopen_tinst_level (struct tinst_level
*);
110 static tree
tsubst_initializer_list (tree
, tree
);
111 static tree
get_class_bindings (tree
, tree
, tree
);
112 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
114 static void tsubst_enum (tree
, tree
, tree
);
115 static tree
add_to_template_args (tree
, tree
);
116 static tree
add_outermost_template_args (tree
, tree
);
117 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
118 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
120 static int type_unification_real (tree
, tree
, tree
, tree
,
121 int, unification_kind_t
, int);
122 static void note_template_header (int);
123 static tree
convert_nontype_argument_function (tree
, tree
);
124 static tree
convert_nontype_argument (tree
, tree
);
125 static tree
convert_template_argument (tree
, tree
, tree
,
126 tsubst_flags_t
, int, tree
);
127 static int for_each_template_parm (tree
, tree_fn_t
, void*,
128 struct pointer_set_t
*, bool);
129 static tree
expand_template_argument_pack (tree
);
130 static tree
build_template_parm_index (int, int, int, tree
, tree
);
131 static bool inline_needs_template_parms (tree
);
132 static void push_inline_template_parms_recursive (tree
, int);
133 static tree
retrieve_local_specialization (tree
);
134 static void register_local_specialization (tree
, tree
);
135 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
136 static int mark_template_parm (tree
, void *);
137 static int template_parm_this_level_p (tree
, void *);
138 static tree
tsubst_friend_function (tree
, tree
);
139 static tree
tsubst_friend_class (tree
, tree
);
140 static int can_complete_type_without_circularity (tree
);
141 static tree
get_bindings (tree
, tree
, tree
, bool);
142 static int template_decl_level (tree
);
143 static int check_cv_quals_for_unify (int, tree
, tree
);
144 static void template_parm_level_and_index (tree
, int*, int*);
145 static int unify_pack_expansion (tree
, tree
, tree
, tree
, int, bool, bool);
146 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
147 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
148 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
149 static void regenerate_decl_from_template (tree
, tree
);
150 static tree
most_specialized_class (tree
, tree
);
151 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
152 static tree
tsubst_arg_types (tree
, tree
, tsubst_flags_t
, tree
);
153 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
154 static bool check_specialization_scope (void);
155 static tree
process_partial_specialization (tree
);
156 static void set_current_access_from_decl (tree
);
157 static tree
get_template_base (tree
, tree
, tree
, tree
);
158 static tree
try_class_unification (tree
, tree
, tree
, tree
);
159 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
161 static bool template_template_parm_bindings_ok_p (tree
, tree
);
162 static int template_args_equal (tree
, tree
);
163 static void tsubst_default_arguments (tree
);
164 static tree
for_each_template_parm_r (tree
*, int *, void *);
165 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
166 static void copy_default_args_to_explicit_spec (tree
);
167 static int invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
168 static int eq_local_specializations (const void *, const void *);
169 static bool dependent_template_arg_p (tree
);
170 static bool any_template_arguments_need_structural_equality_p (tree
);
171 static bool dependent_type_p_r (tree
);
172 static tree
tsubst (tree
, tree
, tsubst_flags_t
, tree
);
173 static tree
tsubst_expr (tree
, tree
, tsubst_flags_t
, tree
, bool);
174 static tree
tsubst_copy (tree
, tree
, tsubst_flags_t
, tree
);
175 static tree
tsubst_pack_expansion (tree
, tree
, tsubst_flags_t
, tree
);
177 /* Make the current scope suitable for access checking when we are
178 processing T. T can be FUNCTION_DECL for instantiated function
179 template, or VAR_DECL for static member variable (need by
180 instantiate_decl). */
183 push_access_scope (tree t
)
185 gcc_assert (TREE_CODE (t
) == FUNCTION_DECL
186 || TREE_CODE (t
) == VAR_DECL
);
188 if (DECL_FRIEND_CONTEXT (t
))
189 push_nested_class (DECL_FRIEND_CONTEXT (t
));
190 else if (DECL_CLASS_SCOPE_P (t
))
191 push_nested_class (DECL_CONTEXT (t
));
193 push_to_top_level ();
195 if (TREE_CODE (t
) == FUNCTION_DECL
)
197 saved_access_scope
= tree_cons
198 (NULL_TREE
, current_function_decl
, saved_access_scope
);
199 current_function_decl
= t
;
203 /* Restore the scope set up by push_access_scope. T is the node we
207 pop_access_scope (tree t
)
209 if (TREE_CODE (t
) == FUNCTION_DECL
)
211 current_function_decl
= TREE_VALUE (saved_access_scope
);
212 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
215 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
218 pop_from_top_level ();
221 /* Do any processing required when DECL (a member template
222 declaration) is finished. Returns the TEMPLATE_DECL corresponding
223 to DECL, unless it is a specialization, in which case the DECL
224 itself is returned. */
227 finish_member_template_decl (tree decl
)
229 if (decl
== error_mark_node
)
230 return error_mark_node
;
232 gcc_assert (DECL_P (decl
));
234 if (TREE_CODE (decl
) == TYPE_DECL
)
238 type
= TREE_TYPE (decl
);
239 if (type
== error_mark_node
)
240 return error_mark_node
;
241 if (IS_AGGR_TYPE (type
)
242 && CLASSTYPE_TEMPLATE_INFO (type
)
243 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
245 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
246 check_member_template (tmpl
);
251 else if (TREE_CODE (decl
) == FIELD_DECL
)
252 error ("data member %qD cannot be a member template", decl
);
253 else if (DECL_TEMPLATE_INFO (decl
))
255 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
257 check_member_template (DECL_TI_TEMPLATE (decl
));
258 return DECL_TI_TEMPLATE (decl
);
264 error ("invalid member template declaration %qD", decl
);
266 return error_mark_node
;
269 /* Return the template info node corresponding to T, whatever T is. */
272 get_template_info (tree t
)
274 tree tinfo
= NULL_TREE
;
276 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
277 tinfo
= DECL_TEMPLATE_INFO (t
);
279 if (!tinfo
&& TREE_CODE (t
) == TYPE_DECL
)
282 if (TAGGED_TYPE_P (t
))
283 tinfo
= TYPE_TEMPLATE_INFO (t
);
288 /* Returns the template nesting level of the indicated class TYPE.
298 A<T>::B<U> has depth two, while A<T> has depth one.
299 Both A<T>::B<int> and A<int>::B<U> have depth one, if
300 they are instantiations, not specializations.
302 This function is guaranteed to return 0 if passed NULL_TREE so
303 that, for example, `template_class_depth (current_class_type)' is
307 template_class_depth (tree type
)
312 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
313 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
314 ? CP_DECL_CONTEXT (type
) : TYPE_CONTEXT (type
))
316 tree tinfo
= get_template_info (type
);
318 if (tinfo
&& PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
))
319 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
))))
326 /* Subroutine of maybe_begin_member_template_processing.
327 Returns true if processing DECL needs us to push template parms. */
330 inline_needs_template_parms (tree decl
)
332 if (! DECL_TEMPLATE_INFO (decl
))
335 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
336 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
339 /* Subroutine of maybe_begin_member_template_processing.
340 Push the template parms in PARMS, starting from LEVELS steps into the
341 chain, and ending at the beginning, since template parms are listed
345 push_inline_template_parms_recursive (tree parmlist
, int levels
)
347 tree parms
= TREE_VALUE (parmlist
);
351 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
353 ++processing_template_decl
;
354 current_template_parms
355 = tree_cons (size_int (processing_template_decl
),
356 parms
, current_template_parms
);
357 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
359 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
361 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
363 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
365 if (parm
== error_mark_node
)
368 gcc_assert (DECL_P (parm
));
370 switch (TREE_CODE (parm
))
379 /* Make a CONST_DECL as is done in process_template_parm.
380 It is ugly that we recreate this here; the original
381 version built in process_template_parm is no longer
383 tree decl
= build_decl (CONST_DECL
, DECL_NAME (parm
),
385 DECL_ARTIFICIAL (decl
) = 1;
386 TREE_CONSTANT (decl
) = 1;
387 TREE_INVARIANT (decl
) = 1;
388 TREE_READONLY (decl
) = 1;
389 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
390 SET_DECL_TEMPLATE_PARM_P (decl
);
401 /* Restore the template parameter context for a member template or
402 a friend template defined in a class definition. */
405 maybe_begin_member_template_processing (tree decl
)
410 if (inline_needs_template_parms (decl
))
412 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
413 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
415 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
418 parms
= TREE_CHAIN (parms
);
421 push_inline_template_parms_recursive (parms
, levels
);
424 /* Remember how many levels of template parameters we pushed so that
425 we can pop them later. */
426 VEC_safe_push (int, heap
, inline_parm_levels
, levels
);
429 /* Undo the effects of maybe_begin_member_template_processing. */
432 maybe_end_member_template_processing (void)
437 if (VEC_length (int, inline_parm_levels
) == 0)
440 last
= VEC_pop (int, inline_parm_levels
);
441 for (i
= 0; i
< last
; ++i
)
443 --processing_template_decl
;
444 current_template_parms
= TREE_CHAIN (current_template_parms
);
449 /* Return a new template argument vector which contains all of ARGS,
450 but has as its innermost set of arguments the EXTRA_ARGS. */
453 add_to_template_args (tree args
, tree extra_args
)
460 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
461 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
463 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
464 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
466 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
467 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
472 /* Like add_to_template_args, but only the outermost ARGS are added to
473 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
474 (EXTRA_ARGS) levels are added. This function is used to combine
475 the template arguments from a partial instantiation with the
476 template arguments used to attain the full instantiation from the
477 partial instantiation. */
480 add_outermost_template_args (tree args
, tree extra_args
)
484 /* If there are more levels of EXTRA_ARGS than there are ARGS,
485 something very fishy is going on. */
486 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
488 /* If *all* the new arguments will be the EXTRA_ARGS, just return
490 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
493 /* For the moment, we make ARGS look like it contains fewer levels. */
494 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
496 new_args
= add_to_template_args (args
, extra_args
);
498 /* Now, we restore ARGS to its full dimensions. */
499 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
504 /* Return the N levels of innermost template arguments from the ARGS. */
507 get_innermost_template_args (tree args
, int n
)
515 /* If N is 1, just return the innermost set of template arguments. */
517 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
519 /* If we're not removing anything, just return the arguments we were
521 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
522 gcc_assert (extra_levels
>= 0);
523 if (extra_levels
== 0)
526 /* Make a new set of arguments, not containing the outer arguments. */
527 new_args
= make_tree_vec (n
);
528 for (i
= 1; i
<= n
; ++i
)
529 SET_TMPL_ARGS_LEVEL (new_args
, i
,
530 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
535 /* The inverse of get_innermost_template_args: Return all but the innermost
536 EXTRA_LEVELS levels of template arguments from the ARGS. */
539 strip_innermost_template_args (tree args
, int extra_levels
)
542 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
547 /* If N is 1, just return the outermost set of template arguments. */
549 return TMPL_ARGS_LEVEL (args
, 1);
551 /* If we're not removing anything, just return the arguments we were
553 gcc_assert (extra_levels
>= 0);
554 if (extra_levels
== 0)
557 /* Make a new set of arguments, not containing the inner arguments. */
558 new_args
= make_tree_vec (n
);
559 for (i
= 1; i
<= n
; ++i
)
560 SET_TMPL_ARGS_LEVEL (new_args
, i
,
561 TMPL_ARGS_LEVEL (args
, i
));
566 /* We've got a template header coming up; push to a new level for storing
570 begin_template_parm_list (void)
572 /* We use a non-tag-transparent scope here, which causes pushtag to
573 put tags in this scope, rather than in the enclosing class or
574 namespace scope. This is the right thing, since we want
575 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
576 global template class, push_template_decl handles putting the
577 TEMPLATE_DECL into top-level scope. For a nested template class,
580 template <class T> struct S1 {
581 template <class T> struct S2 {};
584 pushtag contains special code to call pushdecl_with_scope on the
585 TEMPLATE_DECL for S2. */
586 begin_scope (sk_template_parms
, NULL
);
587 ++processing_template_decl
;
588 ++processing_template_parmlist
;
589 note_template_header (0);
592 /* This routine is called when a specialization is declared. If it is
593 invalid to declare a specialization here, an error is reported and
594 false is returned, otherwise this routine will return true. */
597 check_specialization_scope (void)
599 tree scope
= current_scope ();
603 An explicit specialization shall be declared in the namespace of
604 which the template is a member, or, for member templates, in the
605 namespace of which the enclosing class or enclosing class
606 template is a member. An explicit specialization of a member
607 function, member class or static data member of a class template
608 shall be declared in the namespace of which the class template
610 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
612 error ("explicit specialization in non-namespace scope %qD", scope
);
618 In an explicit specialization declaration for a member of a class
619 template or a member template that appears in namespace scope,
620 the member template and some of its enclosing class templates may
621 remain unspecialized, except that the declaration shall not
622 explicitly specialize a class member template if its enclosing
623 class templates are not explicitly specialized as well. */
624 if (current_template_parms
)
626 error ("enclosing class templates are not explicitly specialized");
633 /* We've just seen template <>. */
636 begin_specialization (void)
638 begin_scope (sk_template_spec
, NULL
);
639 note_template_header (1);
640 return check_specialization_scope ();
643 /* Called at then end of processing a declaration preceded by
647 end_specialization (void)
650 reset_specialization ();
653 /* Any template <>'s that we have seen thus far are not referring to a
654 function specialization. */
657 reset_specialization (void)
659 processing_specialization
= 0;
660 template_header_count
= 0;
663 /* We've just seen a template header. If SPECIALIZATION is nonzero,
664 it was of the form template <>. */
667 note_template_header (int specialization
)
669 processing_specialization
= specialization
;
670 template_header_count
++;
673 /* We're beginning an explicit instantiation. */
676 begin_explicit_instantiation (void)
678 gcc_assert (!processing_explicit_instantiation
);
679 processing_explicit_instantiation
= true;
684 end_explicit_instantiation (void)
686 gcc_assert (processing_explicit_instantiation
);
687 processing_explicit_instantiation
= false;
690 /* An explicit specialization or partial specialization TMPL is being
691 declared. Check that the namespace in which the specialization is
692 occurring is permissible. Returns false iff it is invalid to
693 specialize TMPL in the current namespace. */
696 check_specialization_namespace (tree tmpl
)
698 tree tpl_ns
= decl_namespace_context (tmpl
);
702 An explicit specialization shall be declared in the namespace of
703 which the template is a member, or, for member templates, in the
704 namespace of which the enclosing class or enclosing class
705 template is a member. An explicit specialization of a member
706 function, member class or static data member of a class template
707 shall be declared in the namespace of which the class template is
709 if (is_associated_namespace (current_namespace
, tpl_ns
))
710 /* Same or super-using namespace. */
714 pedwarn ("specialization of %qD in different namespace", tmpl
);
715 pedwarn (" from definition of %q+#D", tmpl
);
720 /* SPEC is an explicit instantiation. Check that it is valid to
721 perform this explicit instantiation in the current namespace. */
724 check_explicit_instantiation_namespace (tree spec
)
728 /* DR 275: An explicit instantiation shall appear in an enclosing
729 namespace of its template. */
730 ns
= decl_namespace_context (spec
);
731 if (!is_ancestor (current_namespace
, ns
))
732 pedwarn ("explicit instantiation of %qD in namespace %qD "
733 "(which does not enclose namespace %qD)",
734 spec
, current_namespace
, ns
);
737 /* The TYPE is being declared. If it is a template type, that means it
738 is a partial specialization. Do appropriate error-checking. */
741 maybe_process_partial_specialization (tree type
)
745 if (type
== error_mark_node
)
746 return error_mark_node
;
748 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
750 error ("name of class shadows template template parameter %qD",
752 return error_mark_node
;
755 context
= TYPE_CONTEXT (type
);
757 if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
759 /* This is for ordinary explicit specialization and partial
760 specialization of a template class such as:
762 template <> class C<int>;
766 template <class T> class C<T*>;
768 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
770 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
771 && !COMPLETE_TYPE_P (type
))
773 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type
));
774 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
775 if (processing_template_decl
)
776 push_template_decl (TYPE_MAIN_DECL (type
));
778 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
779 error ("specialization of %qT after instantiation", type
);
781 else if (CLASS_TYPE_P (type
)
782 && !CLASSTYPE_USE_TEMPLATE (type
)
783 && CLASSTYPE_TEMPLATE_INFO (type
)
784 && context
&& CLASS_TYPE_P (context
)
785 && CLASSTYPE_TEMPLATE_INFO (context
))
787 /* This is for an explicit specialization of member class
788 template according to [temp.expl.spec/18]:
790 template <> template <class U> class C<int>::D;
792 The context `C<int>' must be an implicit instantiation.
793 Otherwise this is just a member class template declared
796 template <> class C<int> { template <class U> class D; };
797 template <> template <class U> class C<int>::D;
799 In the first case, `C<int>::D' is a specialization of `C<T>::D'
800 while in the second case, `C<int>::D' is a primary template
801 and `C<T>::D' may not exist. */
803 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
804 && !COMPLETE_TYPE_P (type
))
808 if (current_namespace
809 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type
)))
811 pedwarn ("specializing %q#T in different namespace", type
);
812 pedwarn (" from definition of %q+#D",
813 CLASSTYPE_TI_TEMPLATE (type
));
816 /* Check for invalid specialization after instantiation:
818 template <> template <> class C<int>::D<int>;
819 template <> template <class U> class C<int>::D; */
821 for (t
= DECL_TEMPLATE_INSTANTIATIONS
822 (most_general_template (CLASSTYPE_TI_TEMPLATE (type
)));
823 t
; t
= TREE_CHAIN (t
))
824 if (TREE_VALUE (t
) != type
825 && TYPE_CONTEXT (TREE_VALUE (t
)) == context
)
826 error ("specialization %qT after instantiation %qT",
827 type
, TREE_VALUE (t
));
829 /* Mark TYPE as a specialization. And as a result, we only
830 have one level of template argument for the innermost
832 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
833 CLASSTYPE_TI_ARGS (type
)
834 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
837 else if (processing_specialization
)
839 error ("explicit specialization of non-template %qT", type
);
840 return error_mark_node
;
846 /* Returns nonzero if we can optimize the retrieval of specializations
847 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
848 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
851 optimize_specialization_lookup_p (tree tmpl
)
853 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
854 && DECL_CLASS_SCOPE_P (tmpl
)
855 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
857 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
858 /* The optimized lookup depends on the fact that the
859 template arguments for the member function template apply
860 purely to the containing class, which is not true if the
861 containing class is an explicit or partial
863 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
864 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
865 && !DECL_CONV_FN_P (tmpl
)
866 /* It is possible to have a template that is not a member
867 template and is not a member of a template class:
869 template <typename T>
870 struct S { friend A::f(); };
872 Here, the friend function is a template, but the context does
873 not have template information. The optimized lookup relies
874 on having ARGS be the template arguments for both the class
875 and the function template. */
876 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
879 /* Retrieve the specialization (in the sense of [temp.spec] - a
880 specialization is either an instantiation or an explicit
881 specialization) of TMPL for the given template ARGS. If there is
882 no such specialization, return NULL_TREE. The ARGS are a vector of
883 arguments, or a vector of vectors of arguments, in the case of
884 templates with more than one level of parameters.
886 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
887 then we search for a partial specialization matching ARGS. This
888 parameter is ignored if TMPL is not a class template. */
891 retrieve_specialization (tree tmpl
, tree args
,
892 bool class_specializations_p
)
894 if (args
== error_mark_node
)
897 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
899 /* There should be as many levels of arguments as there are
900 levels of parameters. */
901 gcc_assert (TMPL_ARGS_DEPTH (args
)
902 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)));
904 if (optimize_specialization_lookup_p (tmpl
))
907 tree class_specialization
;
908 VEC(tree
,gc
) *methods
;
912 /* The template arguments actually apply to the containing
913 class. Find the class specialization with those
915 class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
917 = retrieve_specialization (class_template
, args
,
918 /*class_specializations_p=*/false);
919 if (!class_specialization
)
921 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
922 for the specialization. */
923 idx
= class_method_index_for_fn (class_specialization
, tmpl
);
926 /* Iterate through the methods with the indicated name, looking
927 for the one that has an instance of TMPL. */
928 methods
= CLASSTYPE_METHOD_VEC (class_specialization
);
929 for (fns
= VEC_index (tree
, methods
, idx
); fns
; fns
= OVL_NEXT (fns
))
931 tree fn
= OVL_CURRENT (fns
);
932 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
)
942 /* Class templates store their instantiations on the
943 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
944 DECL_TEMPLATE_SPECIALIZATIONS list. */
945 if (!class_specializations_p
946 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl
)) == TYPE_DECL
947 && TAGGED_TYPE_P (TREE_TYPE (tmpl
)))
948 sp
= &DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
950 sp
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
952 /* Iterate through the list until we find a matching template. */
953 while (*sp
!= NULL_TREE
)
957 if (comp_template_args (TREE_PURPOSE (spec
), args
))
959 /* Use the move-to-front heuristic to speed up future
963 *sp
= TREE_CHAIN (*sp
);
964 TREE_CHAIN (spec
) = *head
;
967 return TREE_VALUE (spec
);
969 sp
= &TREE_CHAIN (spec
);
976 /* Like retrieve_specialization, but for local declarations. */
979 retrieve_local_specialization (tree tmpl
)
983 if (local_specializations
== NULL
)
986 spec
= (tree
) htab_find_with_hash (local_specializations
, tmpl
,
987 htab_hash_pointer (tmpl
));
988 return spec
? TREE_PURPOSE (spec
) : NULL_TREE
;
991 /* Returns nonzero iff DECL is a specialization of TMPL. */
994 is_specialization_of (tree decl
, tree tmpl
)
998 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1002 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1008 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1010 for (t
= TREE_TYPE (decl
);
1012 t
= CLASSTYPE_USE_TEMPLATE (t
)
1013 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1014 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1021 /* Returns nonzero iff DECL is a specialization of friend declaration
1022 FRIEND according to [temp.friend]. */
1025 is_specialization_of_friend (tree decl
, tree
friend)
1027 bool need_template
= true;
1030 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1031 || TREE_CODE (decl
) == TYPE_DECL
);
1033 /* For [temp.friend/6] when FRIEND is an ordinary member function
1034 of a template class, we want to check if DECL is a specialization
1036 if (TREE_CODE (friend) == FUNCTION_DECL
1037 && DECL_TEMPLATE_INFO (friend)
1038 && !DECL_USE_TEMPLATE (friend))
1040 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1041 friend = DECL_TI_TEMPLATE (friend);
1042 need_template
= false;
1044 else if (TREE_CODE (friend) == TEMPLATE_DECL
1045 && !PRIMARY_TEMPLATE_P (friend))
1046 need_template
= false;
1048 /* There is nothing to do if this is not a template friend. */
1049 if (TREE_CODE (friend) != TEMPLATE_DECL
)
1052 if (is_specialization_of (decl
, friend))
1056 A member of a class template may be declared to be a friend of a
1057 non-template class. In this case, the corresponding member of
1058 every specialization of the class template is a friend of the
1059 class granting friendship.
1061 For example, given a template friend declaration
1063 template <class T> friend void A<T>::f();
1065 the member function below is considered a friend
1067 template <> struct A<int> {
1071 For this type of template friend, TEMPLATE_DEPTH below will be
1072 nonzero. To determine if DECL is a friend of FRIEND, we first
1073 check if the enclosing class is a specialization of another. */
1075 template_depth
= template_class_depth (DECL_CONTEXT (friend));
1077 && DECL_CLASS_SCOPE_P (decl
)
1078 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1079 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1081 /* Next, we check the members themselves. In order to handle
1082 a few tricky cases, such as when FRIEND's are
1084 template <class T> friend void A<T>::g(T t);
1085 template <class T> template <T t> friend void A<T>::h();
1089 void A<int>::g(int);
1090 template <int> void A<int>::h();
1092 we need to figure out ARGS, the template arguments from
1093 the context of DECL. This is required for template substitution
1094 of `T' in the function parameter of `g' and template parameter
1095 of `h' in the above examples. Here ARGS corresponds to `int'. */
1097 tree context
= DECL_CONTEXT (decl
);
1098 tree args
= NULL_TREE
;
1099 int current_depth
= 0;
1101 while (current_depth
< template_depth
)
1103 if (CLASSTYPE_TEMPLATE_INFO (context
))
1105 if (current_depth
== 0)
1106 args
= TYPE_TI_ARGS (context
);
1108 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1111 context
= TYPE_CONTEXT (context
);
1114 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1119 tree friend_args_type
;
1120 tree decl_args_type
;
1122 /* Make sure that both DECL and FRIEND are templates or
1124 is_template
= DECL_TEMPLATE_INFO (decl
)
1125 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1126 if (need_template
^ is_template
)
1128 else if (is_template
)
1130 /* If both are templates, check template parameter list. */
1132 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1134 if (!comp_template_parms
1135 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1139 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1142 decl_type
= TREE_TYPE (decl
);
1144 friend_type
= tsubst_function_type (TREE_TYPE (friend), args
,
1145 tf_none
, NULL_TREE
);
1146 if (friend_type
== error_mark_node
)
1149 /* Check if return types match. */
1150 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1153 /* Check if function parameter types match, ignoring the
1154 `this' parameter. */
1155 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1156 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1157 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1158 friend_args_type
= TREE_CHAIN (friend_args_type
);
1159 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1160 decl_args_type
= TREE_CHAIN (decl_args_type
);
1162 return compparms (decl_args_type
, friend_args_type
);
1166 /* DECL is a TYPE_DECL */
1168 tree decl_type
= TREE_TYPE (decl
);
1170 /* Make sure that both DECL and FRIEND are templates or
1173 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1174 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1176 if (need_template
^ is_template
)
1178 else if (is_template
)
1181 /* If both are templates, check the name of the two
1182 TEMPLATE_DECL's first because is_friend didn't. */
1183 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1184 != DECL_NAME (friend))
1187 /* Now check template parameter list. */
1189 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1191 return comp_template_parms
1192 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1196 return (DECL_NAME (decl
)
1197 == DECL_NAME (friend));
1203 /* Register the specialization SPEC as a specialization of TMPL with
1204 the indicated ARGS. IS_FRIEND indicates whether the specialization
1205 is actually just a friend declaration. Returns SPEC, or an
1206 equivalent prior declaration, if available. */
1209 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
)
1213 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1215 if (TREE_CODE (spec
) == FUNCTION_DECL
1216 && uses_template_parms (DECL_TI_ARGS (spec
)))
1217 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1218 register it; we want the corresponding TEMPLATE_DECL instead.
1219 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1220 the more obvious `uses_template_parms (spec)' to avoid problems
1221 with default function arguments. In particular, given
1222 something like this:
1224 template <class T> void f(T t1, T t = T())
1226 the default argument expression is not substituted for in an
1227 instantiation unless and until it is actually needed. */
1230 fn
= retrieve_specialization (tmpl
, args
,
1231 /*class_specializations_p=*/false);
1232 /* We can sometimes try to re-register a specialization that we've
1233 already got. In particular, regenerate_decl_from_template calls
1234 duplicate_decls which will update the specialization list. But,
1235 we'll still get called again here anyhow. It's more convenient
1236 to simply allow this than to try to prevent it. */
1239 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1241 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1244 || DECL_EXPLICIT_INSTANTIATION (fn
))
1246 error ("specialization of %qD after instantiation",
1248 return error_mark_node
;
1253 /* This situation should occur only if the first
1254 specialization is an implicit instantiation, the
1255 second is an explicit specialization, and the
1256 implicit instantiation has not yet been used. That
1257 situation can occur if we have implicitly
1258 instantiated a member function and then specialized
1261 We can also wind up here if a friend declaration that
1262 looked like an instantiation turns out to be a
1265 template <class T> void foo(T);
1266 class S { friend void foo<>(int) };
1267 template <> void foo(int);
1269 We transform the existing DECL in place so that any
1270 pointers to it become pointers to the updated
1273 If there was a definition for the template, but not
1274 for the specialization, we want this to look as if
1275 there were no definition, and vice versa. */
1276 DECL_INITIAL (fn
) = NULL_TREE
;
1277 duplicate_decls (spec
, fn
, is_friend
);
1278 /* The call to duplicate_decls will have applied
1281 An explicit specialization of a function template
1282 is inline only if it is explicitly declared to be,
1283 and independently of whether its function template
1286 to the primary function; now copy the inline bits to
1287 the various clones. */
1288 FOR_EACH_CLONE (clone
, fn
)
1290 DECL_DECLARED_INLINE_P (clone
)
1291 = DECL_DECLARED_INLINE_P (fn
);
1295 check_specialization_namespace (fn
);
1300 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1302 if (!duplicate_decls (spec
, fn
, is_friend
) && DECL_INITIAL (spec
))
1303 /* Dup decl failed, but this is a new definition. Set the
1304 line number so any errors match this new
1306 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1312 /* A specialization must be declared in the same namespace as the
1313 template it is specializing. */
1314 if (DECL_TEMPLATE_SPECIALIZATION (spec
)
1315 && !check_specialization_namespace (tmpl
))
1316 DECL_CONTEXT (spec
) = FROB_CONTEXT (decl_namespace_context (tmpl
));
1318 if (!optimize_specialization_lookup_p (tmpl
))
1319 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
1320 = tree_cons (args
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
1325 /* Unregister the specialization SPEC as a specialization of TMPL.
1326 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1327 if the SPEC was listed as a specialization of TMPL. */
1330 reregister_specialization (tree spec
, tree tmpl
, tree new_spec
)
1334 for (s
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
1336 s
= &TREE_CHAIN (*s
))
1337 if (TREE_VALUE (*s
) == spec
)
1340 *s
= TREE_CHAIN (*s
);
1342 TREE_VALUE (*s
) = new_spec
;
1349 /* Compare an entry in the local specializations hash table P1 (which
1350 is really a pointer to a TREE_LIST) with P2 (which is really a
1354 eq_local_specializations (const void *p1
, const void *p2
)
1356 return TREE_VALUE ((const_tree
) p1
) == (const_tree
) p2
;
1359 /* Hash P1, an entry in the local specializations table. */
1362 hash_local_specialization (const void* p1
)
1364 return htab_hash_pointer (TREE_VALUE ((const_tree
) p1
));
1367 /* Like register_specialization, but for local declarations. We are
1368 registering SPEC, an instantiation of TMPL. */
1371 register_local_specialization (tree spec
, tree tmpl
)
1375 slot
= htab_find_slot_with_hash (local_specializations
, tmpl
,
1376 htab_hash_pointer (tmpl
), INSERT
);
1377 *slot
= build_tree_list (spec
, tmpl
);
1380 /* TYPE is a class type. Returns true if TYPE is an explicitly
1381 specialized class. */
1384 explicit_class_specialization_p (tree type
)
1386 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1388 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1391 /* Print the list of candidate FNS in an error message. */
1394 print_candidates (tree fns
)
1398 const char *str
= "candidates are:";
1400 for (fn
= fns
; fn
!= NULL_TREE
; fn
= TREE_CHAIN (fn
))
1404 for (f
= TREE_VALUE (fn
); f
; f
= OVL_NEXT (f
))
1405 error ("%s %+#D", str
, OVL_CURRENT (f
));
1410 /* Returns the template (one of the functions given by TEMPLATE_ID)
1411 which can be specialized to match the indicated DECL with the
1412 explicit template args given in TEMPLATE_ID. The DECL may be
1413 NULL_TREE if none is available. In that case, the functions in
1414 TEMPLATE_ID are non-members.
1416 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1417 specialization of a member template.
1419 The TEMPLATE_COUNT is the number of references to qualifying
1420 template classes that appeared in the name of the function. See
1421 check_explicit_specialization for a more accurate description.
1423 TSK indicates what kind of template declaration (if any) is being
1424 declared. TSK_TEMPLATE indicates that the declaration given by
1425 DECL, though a FUNCTION_DECL, has template parameters, and is
1426 therefore a template function.
1428 The template args (those explicitly specified and those deduced)
1429 are output in a newly created vector *TARGS_OUT.
1431 If it is impossible to determine the result, an error message is
1432 issued. The error_mark_node is returned to indicate failure. */
1435 determine_specialization (tree template_id
,
1438 int need_member_template
,
1444 tree explicit_targs
;
1445 tree candidates
= NULL_TREE
;
1446 /* A TREE_LIST of templates of which DECL may be a specialization.
1447 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1448 corresponding TREE_PURPOSE is the set of template arguments that,
1449 when used to instantiate the template, would produce a function
1450 with the signature of DECL. */
1451 tree templates
= NULL_TREE
;
1453 struct cp_binding_level
*b
;
1455 *targs_out
= NULL_TREE
;
1457 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
1458 return error_mark_node
;
1460 fns
= TREE_OPERAND (template_id
, 0);
1461 explicit_targs
= TREE_OPERAND (template_id
, 1);
1463 if (fns
== error_mark_node
)
1464 return error_mark_node
;
1466 /* Check for baselinks. */
1467 if (BASELINK_P (fns
))
1468 fns
= BASELINK_FUNCTIONS (fns
);
1470 if (!is_overloaded_fn (fns
))
1472 error ("%qD is not a function template", fns
);
1473 return error_mark_node
;
1476 /* Count the number of template headers specified for this
1479 for (b
= current_binding_level
;
1480 b
->kind
== sk_template_parms
;
1484 for (; fns
; fns
= OVL_NEXT (fns
))
1486 tree fn
= OVL_CURRENT (fns
);
1488 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1490 tree decl_arg_types
;
1493 /* In case of explicit specialization, we need to check if
1494 the number of template headers appearing in the specialization
1495 is correct. This is usually done in check_explicit_specialization,
1496 but the check done there cannot be exhaustive when specializing
1497 member functions. Consider the following code:
1499 template <> void A<int>::f(int);
1500 template <> template <> void A<int>::f(int);
1502 Assuming that A<int> is not itself an explicit specialization
1503 already, the first line specializes "f" which is a non-template
1504 member function, whilst the second line specializes "f" which
1505 is a template member function. So both lines are syntactically
1506 correct, and check_explicit_specialization does not reject
1509 Here, we can do better, as we are matching the specialization
1510 against the declarations. We count the number of template
1511 headers, and we check if they match TEMPLATE_COUNT + 1
1512 (TEMPLATE_COUNT is the number of qualifying template classes,
1513 plus there must be another header for the member template
1516 Notice that if header_count is zero, this is not a
1517 specialization but rather a template instantiation, so there
1518 is no check we can perform here. */
1519 if (header_count
&& header_count
!= template_count
+ 1)
1522 /* Check that the number of template arguments at the
1523 innermost level for DECL is the same as for FN. */
1524 if (current_binding_level
->kind
== sk_template_parms
1525 && !current_binding_level
->explicit_spec_p
1526 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
1527 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1528 (current_template_parms
))))
1531 /* DECL might be a specialization of FN. */
1532 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1533 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1535 /* For a non-static member function, we need to make sure
1536 that the const qualification is the same. Since
1537 get_bindings does not try to merge the "this" parameter,
1538 we must do the comparison explicitly. */
1539 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
1540 && !same_type_p (TREE_VALUE (fn_arg_types
),
1541 TREE_VALUE (decl_arg_types
)))
1544 /* Skip the "this" parameter and, for constructors of
1545 classes with virtual bases, the VTT parameter. A
1546 full specialization of a constructor will have a VTT
1547 parameter, but a template never will. */
1549 = skip_artificial_parms_for (decl
, decl_arg_types
);
1551 = skip_artificial_parms_for (fn
, fn_arg_types
);
1553 /* Check that the number of function parameters matches.
1555 template <class T> void f(int i = 0);
1556 template <> void f<int>();
1557 The specialization f<int> is invalid but is not caught
1558 by get_bindings below. */
1559 if (list_length (fn_arg_types
) != list_length (decl_arg_types
))
1562 /* Function templates cannot be specializations; there are
1563 no partial specializations of functions. Therefore, if
1564 the type of DECL does not match FN, there is no
1566 if (tsk
== tsk_template
)
1568 if (compparms (fn_arg_types
, decl_arg_types
))
1569 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1573 /* See whether this function might be a specialization of this
1575 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
1578 /* We cannot deduce template arguments that when used to
1579 specialize TMPL will produce DECL. */
1582 /* Save this template, and the arguments deduced. */
1583 templates
= tree_cons (targs
, fn
, templates
);
1585 else if (need_member_template
)
1586 /* FN is an ordinary member function, and we need a
1587 specialization of a member template. */
1589 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
1590 /* We can get IDENTIFIER_NODEs here in certain erroneous
1593 else if (!DECL_FUNCTION_MEMBER_P (fn
))
1594 /* This is just an ordinary non-member function. Nothing can
1595 be a specialization of that. */
1597 else if (DECL_ARTIFICIAL (fn
))
1598 /* Cannot specialize functions that are created implicitly. */
1602 tree decl_arg_types
;
1604 /* This is an ordinary member function. However, since
1605 we're here, we can assume it's enclosing class is a
1606 template class. For example,
1608 template <typename T> struct S { void f(); };
1609 template <> void S<int>::f() {}
1611 Here, S<int>::f is a non-template, but S<int> is a
1612 template class. If FN has the same type as DECL, we
1613 might be in business. */
1615 if (!DECL_TEMPLATE_INFO (fn
))
1616 /* Its enclosing class is an explicit specialization
1617 of a template class. This is not a candidate. */
1620 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
1621 TREE_TYPE (TREE_TYPE (fn
))))
1622 /* The return types differ. */
1625 /* Adjust the type of DECL in case FN is a static member. */
1626 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1627 if (DECL_STATIC_FUNCTION_P (fn
)
1628 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1629 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
1631 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1634 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1638 if (templates
&& TREE_CHAIN (templates
))
1644 It is possible for a specialization with a given function
1645 signature to be instantiated from more than one function
1646 template. In such cases, explicit specification of the
1647 template arguments must be used to uniquely identify the
1648 function template specialization being specialized.
1650 Note that here, there's no suggestion that we're supposed to
1651 determine which of the candidate templates is most
1652 specialized. However, we, also have:
1656 Partial ordering of overloaded function template
1657 declarations is used in the following contexts to select
1658 the function template to which a function template
1659 specialization refers:
1661 -- when an explicit specialization refers to a function
1664 So, we do use the partial ordering rules, at least for now.
1665 This extension can only serve to make invalid programs valid,
1666 so it's safe. And, there is strong anecdotal evidence that
1667 the committee intended the partial ordering rules to apply;
1668 the EDG front end has that behavior, and John Spicer claims
1669 that the committee simply forgot to delete the wording in
1670 [temp.expl.spec]. */
1671 tree tmpl
= most_specialized_instantiation (templates
);
1672 if (tmpl
!= error_mark_node
)
1675 TREE_CHAIN (templates
) = NULL_TREE
;
1679 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
1681 error ("template-id %qD for %q+D does not match any template "
1682 "declaration", template_id
, decl
);
1683 return error_mark_node
;
1685 else if ((templates
&& TREE_CHAIN (templates
))
1686 || (candidates
&& TREE_CHAIN (candidates
))
1687 || (templates
&& candidates
))
1689 error ("ambiguous template specialization %qD for %q+D",
1691 chainon (candidates
, templates
);
1692 print_candidates (candidates
);
1693 return error_mark_node
;
1696 /* We have one, and exactly one, match. */
1699 tree fn
= TREE_VALUE (candidates
);
1700 /* DECL is a re-declaration of a template function. */
1701 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1703 /* It was a specialization of an ordinary member function in a
1705 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
1706 return DECL_TI_TEMPLATE (fn
);
1709 /* It was a specialization of a template. */
1710 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
1711 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
1713 *targs_out
= copy_node (targs
);
1714 SET_TMPL_ARGS_LEVEL (*targs_out
,
1715 TMPL_ARGS_DEPTH (*targs_out
),
1716 TREE_PURPOSE (templates
));
1719 *targs_out
= TREE_PURPOSE (templates
);
1720 return TREE_VALUE (templates
);
1723 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1724 but with the default argument values filled in from those in the
1728 copy_default_args_to_explicit_spec_1 (tree spec_types
,
1731 tree new_spec_types
;
1736 if (spec_types
== void_list_node
)
1737 return void_list_node
;
1739 /* Substitute into the rest of the list. */
1741 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
1742 TREE_CHAIN (tmpl_types
));
1744 /* Add the default argument for this parameter. */
1745 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
1746 TREE_VALUE (spec_types
),
1750 /* DECL is an explicit specialization. Replicate default arguments
1751 from the template it specializes. (That way, code like:
1753 template <class T> void f(T = 3);
1754 template <> void f(double);
1757 works, as required.) An alternative approach would be to look up
1758 the correct default arguments at the call-site, but this approach
1759 is consistent with how implicit instantiations are handled. */
1762 copy_default_args_to_explicit_spec (tree decl
)
1767 tree new_spec_types
;
1771 tree object_type
= NULL_TREE
;
1772 tree in_charge
= NULL_TREE
;
1773 tree vtt
= NULL_TREE
;
1775 /* See if there's anything we need to do. */
1776 tmpl
= DECL_TI_TEMPLATE (decl
);
1777 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
1778 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
1779 if (TREE_PURPOSE (t
))
1784 old_type
= TREE_TYPE (decl
);
1785 spec_types
= TYPE_ARG_TYPES (old_type
);
1787 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1789 /* Remove the this pointer, but remember the object's type for
1791 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
1792 spec_types
= TREE_CHAIN (spec_types
);
1793 tmpl_types
= TREE_CHAIN (tmpl_types
);
1795 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
1797 /* DECL may contain more parameters than TMPL due to the extra
1798 in-charge parameter in constructors and destructors. */
1799 in_charge
= spec_types
;
1800 spec_types
= TREE_CHAIN (spec_types
);
1802 if (DECL_HAS_VTT_PARM_P (decl
))
1805 spec_types
= TREE_CHAIN (spec_types
);
1809 /* Compute the merged default arguments. */
1811 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
1813 /* Compute the new FUNCTION_TYPE. */
1817 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
1822 /* Put the in-charge parameter back. */
1823 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
1824 TREE_VALUE (in_charge
),
1827 new_type
= build_method_type_directly (object_type
,
1828 TREE_TYPE (old_type
),
1832 new_type
= build_function_type (TREE_TYPE (old_type
),
1834 new_type
= cp_build_type_attribute_variant (new_type
,
1835 TYPE_ATTRIBUTES (old_type
));
1836 new_type
= build_exception_variant (new_type
,
1837 TYPE_RAISES_EXCEPTIONS (old_type
));
1838 TREE_TYPE (decl
) = new_type
;
1841 /* Check to see if the function just declared, as indicated in
1842 DECLARATOR, and in DECL, is a specialization of a function
1843 template. We may also discover that the declaration is an explicit
1844 instantiation at this point.
1846 Returns DECL, or an equivalent declaration that should be used
1847 instead if all goes well. Issues an error message if something is
1848 amiss. Returns error_mark_node if the error is not easily
1851 FLAGS is a bitmask consisting of the following flags:
1853 2: The function has a definition.
1854 4: The function is a friend.
1856 The TEMPLATE_COUNT is the number of references to qualifying
1857 template classes that appeared in the name of the function. For
1860 template <class T> struct S { void f(); };
1863 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1864 classes are not counted in the TEMPLATE_COUNT, so that in
1866 template <class T> struct S {};
1867 template <> struct S<int> { void f(); }
1868 template <> void S<int>::f();
1870 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1871 invalid; there should be no template <>.)
1873 If the function is a specialization, it is marked as such via
1874 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1875 is set up correctly, and it is added to the list of specializations
1876 for that template. */
1879 check_explicit_specialization (tree declarator
,
1884 int have_def
= flags
& 2;
1885 int is_friend
= flags
& 4;
1886 int specialization
= 0;
1887 int explicit_instantiation
= 0;
1888 int member_specialization
= 0;
1889 tree ctype
= DECL_CLASS_CONTEXT (decl
);
1890 tree dname
= DECL_NAME (decl
);
1895 if (!processing_specialization
)
1898 tsk
= tsk_excessive_parms
;
1901 tsk
= current_tmpl_spec_kind (template_count
);
1906 if (processing_specialization
)
1909 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1911 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1914 /* This could be something like:
1916 template <class T> void f(T);
1917 class S { friend void f<>(int); } */
1921 /* This case handles bogus declarations like template <>
1922 template <class T> void f<int>(); */
1924 error ("template-id %qD in declaration of primary template",
1931 case tsk_invalid_member_spec
:
1932 /* The error has already been reported in
1933 check_specialization_scope. */
1934 return error_mark_node
;
1936 case tsk_invalid_expl_inst
:
1937 error ("template parameter list used in explicit instantiation");
1943 error ("definition provided for explicit instantiation");
1945 explicit_instantiation
= 1;
1948 case tsk_excessive_parms
:
1949 case tsk_insufficient_parms
:
1950 if (tsk
== tsk_excessive_parms
)
1951 error ("too many template parameter lists in declaration of %qD",
1953 else if (template_header_count
)
1954 error("too few template parameter lists in declaration of %qD", decl
);
1956 error("explicit specialization of %qD must be introduced by "
1957 "%<template <>%>", decl
);
1961 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1963 member_specialization
= 1;
1969 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1971 /* This case handles bogus declarations like template <>
1972 template <class T> void f<int>(); */
1974 if (uses_template_parms (declarator
))
1975 error ("function template partial specialization %qD "
1976 "is not allowed", declarator
);
1978 error ("template-id %qD in declaration of primary template",
1983 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
1984 /* This is a specialization of a member template, without
1985 specialization the containing class. Something like:
1987 template <class T> struct S {
1988 template <class U> void f (U);
1990 template <> template <class U> void S<int>::f(U) {}
1992 That's a specialization -- but of the entire template. */
2000 if (specialization
|| member_specialization
)
2002 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2003 for (; t
; t
= TREE_CHAIN (t
))
2004 if (TREE_PURPOSE (t
))
2007 ("default argument specified in explicit specialization");
2012 if (specialization
|| member_specialization
|| explicit_instantiation
)
2014 tree tmpl
= NULL_TREE
;
2015 tree targs
= NULL_TREE
;
2017 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2018 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2022 gcc_assert (TREE_CODE (declarator
) == IDENTIFIER_NODE
);
2027 /* If there is no class context, the explicit instantiation
2028 must be at namespace scope. */
2029 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2031 /* Find the namespace binding, using the declaration
2033 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2035 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2037 error ("%qD is not a template function", dname
);
2038 fns
= error_mark_node
;
2042 tree fn
= OVL_CURRENT (fns
);
2043 if (!is_associated_namespace (CP_DECL_CONTEXT (decl
),
2044 CP_DECL_CONTEXT (fn
)))
2045 error ("%qD is not declared in %qD",
2046 decl
, current_namespace
);
2050 declarator
= lookup_template_function (fns
, NULL_TREE
);
2053 if (declarator
== error_mark_node
)
2054 return error_mark_node
;
2056 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2058 if (!explicit_instantiation
)
2059 /* A specialization in class scope. This is invalid,
2060 but the error will already have been flagged by
2061 check_specialization_scope. */
2062 return error_mark_node
;
2065 /* It's not valid to write an explicit instantiation in
2068 class C { template void f(); }
2070 This case is caught by the parser. However, on
2073 template class C { void f(); };
2075 (which is invalid) we can get here. The error will be
2082 else if (ctype
!= NULL_TREE
2083 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) ==
2086 /* Find the list of functions in ctype that have the same
2087 name as the declared function. */
2088 tree name
= TREE_OPERAND (declarator
, 0);
2089 tree fns
= NULL_TREE
;
2092 if (constructor_name_p (name
, ctype
))
2094 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
2096 if (is_constructor
? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2097 : !CLASSTYPE_DESTRUCTORS (ctype
))
2099 /* From [temp.expl.spec]:
2101 If such an explicit specialization for the member
2102 of a class template names an implicitly-declared
2103 special member function (clause _special_), the
2104 program is ill-formed.
2106 Similar language is found in [temp.explicit]. */
2107 error ("specialization of implicitly-declared special member function");
2108 return error_mark_node
;
2111 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
2114 if (!DECL_CONV_FN_P (decl
))
2116 idx
= lookup_fnfields_1 (ctype
, name
);
2118 fns
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (ctype
), idx
);
2122 VEC(tree
,gc
) *methods
;
2125 /* For a type-conversion operator, we cannot do a
2126 name-based lookup. We might be looking for `operator
2127 int' which will be a specialization of `operator T'.
2128 So, we find *all* the conversion operators, and then
2129 select from them. */
2132 methods
= CLASSTYPE_METHOD_VEC (ctype
);
2134 for (idx
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2135 VEC_iterate (tree
, methods
, idx
, ovl
);
2138 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
2139 /* There are no more conversion functions. */
2142 /* Glue all these conversion functions together
2143 with those we already have. */
2144 for (; ovl
; ovl
= OVL_NEXT (ovl
))
2145 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
2149 if (fns
== NULL_TREE
)
2151 error ("no member function %qD declared in %qT", name
, ctype
);
2152 return error_mark_node
;
2155 TREE_OPERAND (declarator
, 0) = fns
;
2158 /* Figure out what exactly is being specialized at this point.
2159 Note that for an explicit instantiation, even one for a
2160 member function, we cannot tell apriori whether the
2161 instantiation is for a member template, or just a member
2162 function of a template class. Even if a member template is
2163 being instantiated, the member template arguments may be
2164 elided if they can be deduced from the rest of the
2166 tmpl
= determine_specialization (declarator
, decl
,
2168 member_specialization
,
2172 if (!tmpl
|| tmpl
== error_mark_node
)
2173 /* We couldn't figure out what this declaration was
2175 return error_mark_node
;
2178 tree gen_tmpl
= most_general_template (tmpl
);
2180 if (explicit_instantiation
)
2182 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2183 is done by do_decl_instantiation later. */
2185 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2186 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2188 if (arg_depth
> parm_depth
)
2190 /* If TMPL is not the most general template (for
2191 example, if TMPL is a friend template that is
2192 injected into namespace scope), then there will
2193 be too many levels of TARGS. Remove some of them
2198 new_targs
= make_tree_vec (parm_depth
);
2199 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2200 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2201 = TREE_VEC_ELT (targs
, i
);
2205 return instantiate_template (tmpl
, targs
, tf_error
);
2208 /* If we thought that the DECL was a member function, but it
2209 turns out to be specializing a static member function,
2210 make DECL a static member function as well. */
2211 if (DECL_STATIC_FUNCTION_P (tmpl
)
2212 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2213 revert_static_member_fn (decl
);
2215 /* If this is a specialization of a member template of a
2216 template class, we want to return the TEMPLATE_DECL, not
2217 the specialization of it. */
2218 if (tsk
== tsk_template
)
2220 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2221 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
)) = NULL_TREE
;
2224 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
2225 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl
))
2226 = DECL_SOURCE_LOCATION (decl
);
2227 /* We want to use the argument list specified in the
2228 definition, not in the original declaration. */
2229 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl
))
2230 = DECL_ARGUMENTS (decl
);
2235 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2236 DECL_TEMPLATE_INFO (decl
) = tree_cons (tmpl
, targs
, NULL_TREE
);
2238 /* Inherit default function arguments from the template
2239 DECL is specializing. */
2240 copy_default_args_to_explicit_spec (decl
);
2242 /* This specialization has the same protection as the
2243 template it specializes. */
2244 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
2245 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
2247 /* 7.1.1-1 [dcl.stc]
2249 A storage-class-specifier shall not be specified in an
2250 explicit specialization...
2252 The parser rejects these, so unless action is taken here,
2253 explicit function specializations will always appear with
2256 The action recommended by the C++ CWG in response to C++
2257 defect report 605 is to make the storage class and linkage
2258 of the explicit specialization match the templated function:
2260 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2262 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
2264 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
2265 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
2267 /* This specialization has the same linkage and visibility as
2268 the function template it specializes. */
2269 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
2270 if (! TREE_PUBLIC (decl
))
2272 DECL_INTERFACE_KNOWN (decl
) = 1;
2273 DECL_NOT_REALLY_EXTERN (decl
) = 1;
2275 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
2276 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
2278 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
2279 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
2283 /* If DECL is a friend declaration, declared using an
2284 unqualified name, the namespace associated with DECL may
2285 have been set incorrectly. For example, in:
2287 template <typename T> void f(T);
2289 struct S { friend void f<int>(int); }
2292 we will have set the DECL_CONTEXT for the friend
2293 declaration to N, rather than to the global namespace. */
2294 if (DECL_NAMESPACE_SCOPE_P (decl
))
2295 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
2297 if (is_friend
&& !have_def
)
2298 /* This is not really a declaration of a specialization.
2299 It's just the name of an instantiation. But, it's not
2300 a request for an instantiation, either. */
2301 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
2302 else if (DECL_CONSTRUCTOR_P (decl
) || DECL_DESTRUCTOR_P (decl
))
2303 /* This is indeed a specialization. In case of constructors
2304 and destructors, we need in-charge and not-in-charge
2305 versions in V3 ABI. */
2306 clone_function_decl (decl
, /*update_method_vec_p=*/0);
2308 /* Register this specialization so that we can find it
2310 decl
= register_specialization (decl
, gen_tmpl
, targs
, is_friend
);
2317 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2318 parameters. These are represented in the same format used for
2319 DECL_TEMPLATE_PARMS. */
2322 comp_template_parms (const_tree parms1
, const_tree parms2
)
2327 if (parms1
== parms2
)
2330 for (p1
= parms1
, p2
= parms2
;
2331 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
2332 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
2334 tree t1
= TREE_VALUE (p1
);
2335 tree t2
= TREE_VALUE (p2
);
2338 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
2339 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
2341 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
2344 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
2346 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
2347 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
2349 /* If either of the template parameters are invalid, assume
2350 they match for the sake of error recovery. */
2351 if (parm1
== error_mark_node
|| parm2
== error_mark_node
)
2354 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
2357 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
2358 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
2359 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
2361 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
2366 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
2367 /* One set of parameters has more parameters lists than the
2374 /* Determine whether PARM is a parameter pack. */
2376 template_parameter_pack_p (const_tree parm
)
2378 /* Determine if we have a non-type template parameter pack. */
2379 if (TREE_CODE (parm
) == PARM_DECL
)
2380 return (DECL_TEMPLATE_PARM_P (parm
)
2381 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
2383 /* If this is a list of template parameters, we could get a
2384 TYPE_DECL or a TEMPLATE_DECL. */
2385 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
2386 parm
= TREE_TYPE (parm
);
2388 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
2389 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
2390 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
2393 /* Determine whether ARGS describes a variadic template args list,
2394 i.e., one that is terminated by a template argument pack. */
2396 template_args_variadic_p (tree args
)
2401 if (args
== NULL_TREE
)
2404 args
= INNERMOST_TEMPLATE_ARGS (args
);
2405 nargs
= TREE_VEC_LENGTH (args
);
2410 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
2412 return ARGUMENT_PACK_P (last_parm
);
2415 /* Generate a new name for the parameter pack name NAME (an
2416 IDENTIFIER_NODE) that incorporates its */
2418 make_ith_pack_parameter_name (tree name
, int i
)
2420 /* Munge the name to include the parameter index. */
2424 sprintf(numbuf
, "%i", i
);
2425 newname
= (char*)alloca (IDENTIFIER_LENGTH (name
) + strlen(numbuf
) + 2);
2426 sprintf(newname
, "%s#%i", IDENTIFIER_POINTER (name
), i
);
2427 return get_identifier (newname
);
2430 /* Structure used to track the progress of find_parameter_packs_r. */
2431 struct find_parameter_pack_data
2433 /* TREE_LIST that will contain all of the parameter packs found by
2435 tree
* parameter_packs
;
2437 /* Set of AST nodes that have been visited by the traversal. */
2438 struct pointer_set_t
*visited
;
2441 /* Identifies all of the argument packs that occur in a template
2442 argument and appends them to the TREE_LIST inside DATA, which is a
2443 find_parameter_pack_data structure. This is a subroutine of
2444 make_pack_expansion and uses_parameter_packs. */
2446 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
2449 struct find_parameter_pack_data
* ppd
=
2450 (struct find_parameter_pack_data
*)data
;
2451 bool parameter_pack_p
= false;
2453 /* Identify whether this is a parameter pack or not. */
2454 switch (TREE_CODE (t
))
2456 case TEMPLATE_PARM_INDEX
:
2457 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
2458 parameter_pack_p
= true;
2461 case TEMPLATE_TYPE_PARM
:
2462 case TEMPLATE_TEMPLATE_PARM
:
2463 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
2464 parameter_pack_p
= true;
2468 if (FUNCTION_PARAMETER_PACK_P (t
))
2470 /* We don't want to walk into the type of a PARM_DECL,
2471 because we don't want to see the type parameter pack. */
2473 parameter_pack_p
= true;
2478 /* Not a parameter pack. */
2482 if (parameter_pack_p
)
2484 /* Add this parameter pack to the list. */
2485 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
2489 cp_walk_tree (&TYPE_CONTEXT (t
),
2490 &find_parameter_packs_r
, ppd
, ppd
->visited
);
2492 /* This switch statement will return immediately if we don't find a
2494 switch (TREE_CODE (t
))
2496 case TEMPLATE_PARM_INDEX
:
2499 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2500 /* Check the template itself. */
2501 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
2502 &find_parameter_packs_r
, ppd
, ppd
->visited
);
2503 /* Check the template arguments. */
2504 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
2509 case TEMPLATE_TYPE_PARM
:
2510 case TEMPLATE_TEMPLATE_PARM
:
2517 if (TYPE_PTRMEMFUNC_P (t
))
2523 if (TYPE_TEMPLATE_INFO (t
))
2524 cp_walk_tree (&TREE_VALUE (TYPE_TEMPLATE_INFO (t
)),
2525 &find_parameter_packs_r
, ppd
, ppd
->visited
);
2531 cp_walk_tree (&TREE_TYPE (t
),
2532 &find_parameter_packs_r
, ppd
, ppd
->visited
);
2536 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
2541 case TYPE_PACK_EXPANSION
:
2542 case EXPR_PACK_EXPANSION
:
2547 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
2552 case IDENTIFIER_NODE
:
2553 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
2565 /* Determines if the expression or type T uses any parameter packs. */
2567 uses_parameter_packs (tree t
)
2569 tree parameter_packs
= NULL_TREE
;
2570 struct find_parameter_pack_data ppd
;
2571 ppd
.parameter_packs
= ¶meter_packs
;
2572 ppd
.visited
= pointer_set_create ();
2573 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
2574 pointer_set_destroy (ppd
.visited
);
2575 return parameter_packs
!= NULL_TREE
;
2578 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2579 representation a base-class initializer into a parameter pack
2580 expansion. If all goes well, the resulting node will be an
2581 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2584 make_pack_expansion (tree arg
)
2587 tree parameter_packs
= NULL_TREE
;
2588 bool for_types
= false;
2589 struct find_parameter_pack_data ppd
;
2591 if (!arg
|| arg
== error_mark_node
)
2594 if (TREE_CODE (arg
) == TREE_LIST
)
2596 /* The only time we will see a TREE_LIST here is for a base
2597 class initializer. In this case, the TREE_PURPOSE will be a
2598 _TYPE node (representing the base class expansion we're
2599 initializing) and the TREE_VALUE will be a TREE_LIST
2600 containing the initialization arguments.
2602 The resulting expansion looks somewhat different from most
2603 expansions. Rather than returning just one _EXPANSION, we
2604 return a TREE_LIST whose TREE_PURPOSE is a
2605 TYPE_PACK_EXPANSION containing the bases that will be
2606 initialized. The TREE_VALUE will be identical to the
2607 original TREE_VALUE, which is a list of arguments that will
2608 be passed to each base. We do not introduce any new pack
2609 expansion nodes into the TREE_VALUE (although it is possible
2610 that some already exist), because the TREE_PURPOSE and
2611 TREE_VALUE all need to be expanded together with the same
2612 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2613 resulting TREE_PURPOSE will mention the parameter packs in
2614 both the bases and the arguments to the bases. */
2617 tree parameter_packs
= NULL_TREE
;
2619 /* Determine which parameter packs will be used by the base
2621 ppd
.visited
= pointer_set_create ();
2622 ppd
.parameter_packs
= ¶meter_packs
;
2623 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
2626 if (parameter_packs
== NULL_TREE
)
2628 error ("base initializer expansion %<%T%> contains no parameter packs", arg
);
2629 pointer_set_destroy (ppd
.visited
);
2630 return error_mark_node
;
2633 if (TREE_VALUE (arg
) != void_type_node
)
2635 /* Collect the sets of parameter packs used in each of the
2636 initialization arguments. */
2637 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
2639 /* Determine which parameter packs will be expanded in this
2641 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
2646 pointer_set_destroy (ppd
.visited
);
2648 /* Create the pack expansion type for the base type. */
2649 purpose
= make_node (TYPE_PACK_EXPANSION
);
2650 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
2651 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
2653 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2654 they will rarely be compared to anything. */
2655 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
2657 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
2660 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
2663 /* Build the PACK_EXPANSION_* node. */
2664 result
= make_node (for_types
? TYPE_PACK_EXPANSION
: EXPR_PACK_EXPANSION
);
2665 SET_PACK_EXPANSION_PATTERN (result
, arg
);
2666 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
2668 /* Propagate type and const-expression information. */
2669 TREE_TYPE (result
) = TREE_TYPE (arg
);
2670 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
2673 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2674 they will rarely be compared to anything. */
2675 SET_TYPE_STRUCTURAL_EQUALITY (result
);
2677 /* Determine which parameter packs will be expanded. */
2678 ppd
.parameter_packs
= ¶meter_packs
;
2679 ppd
.visited
= pointer_set_create ();
2680 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
2681 pointer_set_destroy (ppd
.visited
);
2683 /* Make sure we found some parameter packs. */
2684 if (parameter_packs
== NULL_TREE
)
2687 error ("expansion pattern %<%T%> contains no argument packs", arg
);
2689 error ("expansion pattern %<%E%> contains no argument packs", arg
);
2690 return error_mark_node
;
2692 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
2697 /* Checks T for any "bare" parameter packs, which have not yet been
2698 expanded, and issues an error if any are found. This operation can
2699 only be done on full expressions or types (e.g., an expression
2700 statement, "if" condition, etc.), because we could have expressions like:
2702 foo(f(g(h(args)))...)
2704 where "args" is a parameter pack. check_for_bare_parameter_packs
2705 should not be called for the subexpressions args, h(args),
2706 g(h(args)), or f(g(h(args))), because we would produce erroneous
2709 Returns TRUE and emits an error if there were bare parameter packs,
2710 returns FALSE otherwise. */
2712 check_for_bare_parameter_packs (tree t
)
2714 tree parameter_packs
= NULL_TREE
;
2715 struct find_parameter_pack_data ppd
;
2717 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
2720 if (TREE_CODE (t
) == TYPE_DECL
)
2723 ppd
.parameter_packs
= ¶meter_packs
;
2724 ppd
.visited
= pointer_set_create ();
2725 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
2726 pointer_set_destroy (ppd
.visited
);
2728 if (parameter_packs
)
2730 error ("parameter packs not expanded with `...':");
2731 while (parameter_packs
)
2733 tree pack
= TREE_VALUE (parameter_packs
);
2734 tree name
= NULL_TREE
;
2736 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
2737 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
2738 name
= TYPE_NAME (pack
);
2739 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
2740 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
2742 name
= DECL_NAME (pack
);
2745 inform (" %qD", name
);
2747 inform (" <anonymous>");
2749 parameter_packs
= TREE_CHAIN (parameter_packs
);
2758 /* Expand any parameter packs that occur in the template arguments in
2761 expand_template_argument_pack (tree args
)
2763 tree result_args
= NULL_TREE
;
2764 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
2765 int num_result_args
= -1;
2767 /* First, determine if we need to expand anything, and the number of
2768 slots we'll need. */
2769 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
2771 tree arg
= TREE_VEC_ELT (args
, in_arg
);
2772 if (ARGUMENT_PACK_P (arg
))
2774 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
2775 if (num_result_args
< 0)
2776 num_result_args
= in_arg
+ num_packed
;
2778 num_result_args
+= num_packed
;
2782 if (num_result_args
>= 0)
2787 /* If no expansion is necessary, we're done. */
2788 if (num_result_args
< 0)
2791 /* Expand arguments. */
2792 result_args
= make_tree_vec (num_result_args
);
2793 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
2795 tree arg
= TREE_VEC_ELT (args
, in_arg
);
2796 if (ARGUMENT_PACK_P (arg
))
2798 tree packed
= ARGUMENT_PACK_ARGS (arg
);
2799 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
2800 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
2801 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
2805 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
2813 /* Complain if DECL shadows a template parameter.
2815 [temp.local]: A template-parameter shall not be redeclared within its
2816 scope (including nested scopes). */
2819 check_template_shadow (tree decl
)
2823 /* If we're not in a template, we can't possibly shadow a template
2825 if (!current_template_parms
)
2828 /* Figure out what we're shadowing. */
2829 if (TREE_CODE (decl
) == OVERLOAD
)
2830 decl
= OVL_CURRENT (decl
);
2831 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
2833 /* If there's no previous binding for this name, we're not shadowing
2834 anything, let alone a template parameter. */
2838 /* If we're not shadowing a template parameter, we're done. Note
2839 that OLDDECL might be an OVERLOAD (or perhaps even an
2840 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2842 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
2845 /* We check for decl != olddecl to avoid bogus errors for using a
2846 name inside a class. We check TPFI to avoid duplicate errors for
2847 inline member templates. */
2849 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
2852 error ("declaration of %q+#D", decl
);
2853 error (" shadows template parm %q+#D", olddecl
);
2856 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2857 ORIG_LEVEL, DECL, and TYPE. */
2860 build_template_parm_index (int index
,
2866 tree t
= make_node (TEMPLATE_PARM_INDEX
);
2867 TEMPLATE_PARM_IDX (t
) = index
;
2868 TEMPLATE_PARM_LEVEL (t
) = level
;
2869 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
2870 TEMPLATE_PARM_DECL (t
) = decl
;
2871 TREE_TYPE (t
) = type
;
2872 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
2873 TREE_INVARIANT (t
) = TREE_INVARIANT (decl
);
2874 TREE_READONLY (t
) = TREE_READONLY (decl
);
2879 /* Find the canonical type parameter for the given template type
2880 parameter. Returns the canonical type parameter, which may be TYPE
2881 if no such parameter existed. */
2883 canonical_type_parameter (tree type
)
2886 int idx
= TEMPLATE_TYPE_IDX (type
);
2887 if (!canonical_template_parms
)
2888 canonical_template_parms
= VEC_alloc (tree
, gc
, idx
+1);
2890 while (VEC_length (tree
, canonical_template_parms
) <= (unsigned)idx
)
2891 VEC_safe_push (tree
, gc
, canonical_template_parms
, NULL_TREE
);
2893 list
= VEC_index (tree
, canonical_template_parms
, idx
);
2894 while (list
&& !cp_comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
2895 list
= TREE_CHAIN (list
);
2898 return TREE_VALUE (list
);
2901 VEC_replace(tree
, canonical_template_parms
, idx
,
2902 tree_cons (NULL_TREE
, type
,
2903 VEC_index (tree
, canonical_template_parms
, idx
)));
2908 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2909 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2910 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2911 new one is created. */
2914 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
2915 tsubst_flags_t complain
)
2917 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
2918 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
2919 != TEMPLATE_PARM_LEVEL (index
) - levels
))
2921 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
2924 decl
= build_decl (TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
2925 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
2926 TREE_INVARIANT (decl
) = TREE_INVARIANT (orig_decl
);
2927 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
2928 DECL_ARTIFICIAL (decl
) = 1;
2929 SET_DECL_TEMPLATE_PARM_P (decl
);
2931 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
2932 TEMPLATE_PARM_LEVEL (index
) - levels
,
2933 TEMPLATE_PARM_ORIG_LEVEL (index
),
2935 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
2936 TEMPLATE_PARM_PARAMETER_PACK (t
)
2937 = TEMPLATE_PARM_PARAMETER_PACK (index
);
2939 /* Template template parameters need this. */
2940 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2941 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
2942 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
)),
2946 return TEMPLATE_PARM_DESCENDANTS (index
);
2949 /* Process information from new template parameter PARM and append it to the
2950 LIST being built. This new parameter is a non-type parameter iff
2951 IS_NON_TYPE is true. This new parameter is a parameter
2952 pack iff IS_PARAMETER_PACK is true. */
2955 process_template_parm (tree list
, tree parm
, bool is_non_type
,
2956 bool is_parameter_pack
)
2963 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
2964 defval
= TREE_PURPOSE (parm
);
2968 tree p
= tree_last (list
);
2970 if (p
&& TREE_VALUE (p
) != error_mark_node
)
2973 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
2974 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
2976 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
2986 parm
= TREE_VALUE (parm
);
2988 SET_DECL_TEMPLATE_PARM_P (parm
);
2990 if (TREE_TYPE (parm
) == error_mark_node
)
2992 err_parm_list
= build_tree_list (defval
, parm
);
2993 TREE_VALUE (err_parm_list
) = error_mark_node
;
2994 return chainon (list
, err_parm_list
);
3000 The top-level cv-qualifiers on the template-parameter are
3001 ignored when determining its type. */
3002 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
3003 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
3005 err_parm_list
= build_tree_list (defval
, parm
);
3006 TREE_VALUE (err_parm_list
) = error_mark_node
;
3007 return chainon (list
, err_parm_list
);
3010 if (uses_parameter_packs (TREE_TYPE (parm
)) && !is_parameter_pack
)
3012 /* This template parameter is not a parameter pack, but it
3013 should be. Complain about "bare" parameter packs. */
3014 check_for_bare_parameter_packs (TREE_TYPE (parm
));
3016 /* Recover by calling this a parameter pack. */
3017 is_parameter_pack
= true;
3021 /* A template parameter is not modifiable. */
3022 TREE_CONSTANT (parm
) = 1;
3023 TREE_INVARIANT (parm
) = 1;
3024 TREE_READONLY (parm
) = 1;
3025 decl
= build_decl (CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
3026 TREE_CONSTANT (decl
) = 1;
3027 TREE_INVARIANT (decl
) = 1;
3028 TREE_READONLY (decl
) = 1;
3029 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
3030 = build_template_parm_index (idx
, processing_template_decl
,
3031 processing_template_decl
,
3032 decl
, TREE_TYPE (parm
));
3034 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
3035 = is_parameter_pack
;
3040 parm
= TREE_VALUE (TREE_VALUE (parm
));
3042 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
3044 t
= make_aggr_type (TEMPLATE_TEMPLATE_PARM
);
3045 /* This is for distinguishing between real templates and template
3046 template parameters */
3047 TREE_TYPE (parm
) = t
;
3048 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
3053 t
= make_aggr_type (TEMPLATE_TYPE_PARM
);
3054 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3055 decl
= build_decl (TYPE_DECL
, parm
, t
);
3058 TYPE_NAME (t
) = decl
;
3059 TYPE_STUB_DECL (t
) = decl
;
3061 TEMPLATE_TYPE_PARM_INDEX (t
)
3062 = build_template_parm_index (idx
, processing_template_decl
,
3063 processing_template_decl
,
3064 decl
, TREE_TYPE (parm
));
3065 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
3066 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
3068 DECL_ARTIFICIAL (decl
) = 1;
3069 SET_DECL_TEMPLATE_PARM_P (decl
);
3071 parm
= build_tree_list (defval
, parm
);
3072 return chainon (list
, parm
);
3075 /* The end of a template parameter list has been reached. Process the
3076 tree list into a parameter vector, converting each parameter into a more
3077 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3081 end_template_parm_list (tree parms
)
3085 tree saved_parmlist
= make_tree_vec (list_length (parms
));
3087 current_template_parms
3088 = tree_cons (size_int (processing_template_decl
),
3089 saved_parmlist
, current_template_parms
);
3091 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
3093 next
= TREE_CHAIN (parm
);
3094 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
3095 TREE_CHAIN (parm
) = NULL_TREE
;
3098 --processing_template_parmlist
;
3100 return saved_parmlist
;
3103 /* end_template_decl is called after a template declaration is seen. */
3106 end_template_decl (void)
3108 reset_specialization ();
3110 if (! processing_template_decl
)
3113 /* This matches the pushlevel in begin_template_parm_list. */
3116 --processing_template_decl
;
3117 current_template_parms
= TREE_CHAIN (current_template_parms
);
3120 /* Within the declaration of a template, return all levels of template
3121 parameters that apply. The template parameters are represented as
3122 a TREE_VEC, in the form documented in cp-tree.h for template
3126 current_template_args (void)
3129 tree args
= NULL_TREE
;
3130 int length
= TMPL_PARMS_DEPTH (current_template_parms
);
3133 /* If there is only one level of template parameters, we do not
3134 create a TREE_VEC of TREE_VECs. Instead, we return a single
3135 TREE_VEC containing the arguments. */
3137 args
= make_tree_vec (length
);
3139 for (header
= current_template_parms
; header
; header
= TREE_CHAIN (header
))
3141 tree a
= copy_node (TREE_VALUE (header
));
3144 TREE_TYPE (a
) = NULL_TREE
;
3145 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
3147 tree t
= TREE_VEC_ELT (a
, i
);
3149 /* T will be a list if we are called from within a
3150 begin/end_template_parm_list pair, but a vector directly
3151 if within a begin/end_member_template_processing pair. */
3152 if (TREE_CODE (t
) == TREE_LIST
)
3156 if (!error_operand_p (t
))
3158 if (TREE_CODE (t
) == TYPE_DECL
3159 || TREE_CODE (t
) == TEMPLATE_DECL
)
3163 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3165 /* Turn this argument into a TYPE_ARGUMENT_PACK
3166 with a single element, which expands T. */
3167 tree vec
= make_tree_vec (1);
3168 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3170 t
= make_node (TYPE_ARGUMENT_PACK
);
3171 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3176 t
= DECL_INITIAL (t
);
3178 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3180 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3181 with a single element, which expands T. */
3182 tree vec
= make_tree_vec (1);
3183 tree type
= TREE_TYPE (TEMPLATE_PARM_DECL (t
));
3184 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
3186 t
= make_node (NONTYPE_ARGUMENT_PACK
);
3187 SET_ARGUMENT_PACK_ARGS (t
, vec
);
3188 TREE_TYPE (t
) = type
;
3191 TREE_VEC_ELT (a
, i
) = t
;
3197 TREE_VEC_ELT (args
, --l
) = a
;
3205 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3206 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3207 a member template. Used by push_template_decl below. */
3210 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
3212 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
3213 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
3214 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
3215 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
3216 if (DECL_LANG_SPECIFIC (decl
))
3218 DECL_STATIC_FUNCTION_P (tmpl
) = DECL_STATIC_FUNCTION_P (decl
);
3219 DECL_CONSTRUCTOR_P (tmpl
) = DECL_CONSTRUCTOR_P (decl
);
3220 DECL_DESTRUCTOR_P (tmpl
) = DECL_DESTRUCTOR_P (decl
);
3221 DECL_NONCONVERTING_P (tmpl
) = DECL_NONCONVERTING_P (decl
);
3222 DECL_ASSIGNMENT_OPERATOR_P (tmpl
) = DECL_ASSIGNMENT_OPERATOR_P (decl
);
3223 if (DECL_OVERLOADED_OPERATOR_P (decl
))
3224 SET_OVERLOADED_OPERATOR_CODE (tmpl
,
3225 DECL_OVERLOADED_OPERATOR_P (decl
));
3231 struct template_parm_data
3233 /* The level of the template parameters we are currently
3237 /* The index of the specialization argument we are currently
3241 /* An array whose size is the number of template parameters. The
3242 elements are nonzero if the parameter has been used in any one
3243 of the arguments processed so far. */
3246 /* An array whose size is the number of template arguments. The
3247 elements are nonzero if the argument makes use of template
3248 parameters of this level. */
3249 int* arg_uses_template_parms
;
3252 /* Subroutine of push_template_decl used to see if each template
3253 parameter in a partial specialization is used in the explicit
3254 argument list. If T is of the LEVEL given in DATA (which is
3255 treated as a template_parm_data*), then DATA->PARMS is marked
3259 mark_template_parm (tree t
, void* data
)
3263 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
3265 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
3267 level
= TEMPLATE_PARM_LEVEL (t
);
3268 idx
= TEMPLATE_PARM_IDX (t
);
3272 level
= TEMPLATE_TYPE_LEVEL (t
);
3273 idx
= TEMPLATE_TYPE_IDX (t
);
3276 if (level
== tpd
->level
)
3278 tpd
->parms
[idx
] = 1;
3279 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
3282 /* Return zero so that for_each_template_parm will continue the
3283 traversal of the tree; we want to mark *every* template parm. */
3287 /* Process the partial specialization DECL. */
3290 process_partial_specialization (tree decl
)
3292 tree type
= TREE_TYPE (decl
);
3293 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
3294 tree specargs
= CLASSTYPE_TI_ARGS (type
);
3295 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
3296 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
3297 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
3298 int nargs
= TREE_VEC_LENGTH (inner_args
);
3299 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
3301 int did_error_intro
= 0;
3302 struct template_parm_data tpd
;
3303 struct template_parm_data tpd2
;
3305 /* We check that each of the template parameters given in the
3306 partial specialization is used in the argument list to the
3307 specialization. For example:
3309 template <class T> struct S;
3310 template <class T> struct S<T*>;
3312 The second declaration is OK because `T*' uses the template
3313 parameter T, whereas
3315 template <class T> struct S<int>;
3317 is no good. Even trickier is:
3328 The S2<T> declaration is actually invalid; it is a
3329 full-specialization. Of course,
3332 struct S2<T (*)(U)>;
3334 or some such would have been OK. */
3335 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
3336 tpd
.parms
= (int *) alloca (sizeof (int) * ntparms
);
3337 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
3339 tpd
.arg_uses_template_parms
= (int *) alloca (sizeof (int) * nargs
);
3340 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
3341 for (i
= 0; i
< nargs
; ++i
)
3343 tpd
.current_arg
= i
;
3344 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
3345 &mark_template_parm
,
3348 /*include_nondeduced_p=*/false);
3350 for (i
= 0; i
< ntparms
; ++i
)
3351 if (tpd
.parms
[i
] == 0)
3353 /* One of the template parms was not used in the
3355 if (!did_error_intro
)
3357 error ("template parameters not used in partial specialization:");
3358 did_error_intro
= 1;
3361 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
3364 /* [temp.class.spec]
3366 The argument list of the specialization shall not be identical to
3367 the implicit argument list of the primary template. */
3368 if (comp_template_args
3370 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3372 error ("partial specialization %qT does not specialize any template arguments", type
);
3374 /* [temp.class.spec]
3376 A partially specialized non-type argument expression shall not
3377 involve template parameters of the partial specialization except
3378 when the argument expression is a simple identifier.
3380 The type of a template parameter corresponding to a specialized
3381 non-type argument shall not be dependent on a parameter of the
3384 Also, we verify that pack expansions only occur at the
3385 end of the argument list. */
3386 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
3388 for (i
= 0; i
< nargs
; ++i
)
3390 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
3391 tree arg
= TREE_VEC_ELT (inner_args
, i
);
3392 tree packed_args
= NULL_TREE
;
3395 if (ARGUMENT_PACK_P (arg
))
3397 /* Extract the arguments from the argument pack. We'll be
3398 iterating over these in the following loop. */
3399 packed_args
= ARGUMENT_PACK_ARGS (arg
);
3400 len
= TREE_VEC_LENGTH (packed_args
);
3403 for (j
= 0; j
< len
; j
++)
3406 /* Get the Jth argument in the parameter pack. */
3407 arg
= TREE_VEC_ELT (packed_args
, j
);
3409 if (PACK_EXPANSION_P (arg
))
3411 /* Pack expansions must come at the end of the
3413 if ((packed_args
&& j
< len
- 1)
3414 || (!packed_args
&& i
< nargs
- 1))
3416 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
3417 error ("parameter pack argument %qE must be at the end of the template argument list", arg
);
3419 error ("parameter pack argument %qT must be at the end of the template argument list", arg
);
3422 TREE_VEC_ELT (packed_args
, j
) = error_mark_node
;
3426 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
3427 /* We only care about the pattern. */
3428 arg
= PACK_EXPANSION_PATTERN (arg
);
3430 if (/* These first two lines are the `non-type' bit. */
3432 && TREE_CODE (arg
) != TEMPLATE_DECL
3433 /* This next line is the `argument expression is not just a
3434 simple identifier' condition and also the `specialized
3435 non-type argument' bit. */
3436 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
)
3438 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
3439 || (packed_args
&& uses_template_parms (arg
)))
3440 error ("template argument %qE involves template parameter(s)",
3444 /* Look at the corresponding template parameter,
3445 marking which template parameters its type depends
3447 tree type
= TREE_TYPE (parm
);
3451 /* We haven't yet initialized TPD2. Do so now. */
3452 tpd2
.arg_uses_template_parms
3453 = (int *) alloca (sizeof (int) * nargs
);
3454 /* The number of parameters here is the number in the
3455 main template, which, as checked in the assertion
3457 tpd2
.parms
= (int *) alloca (sizeof (int) * nargs
);
3459 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
3462 /* Mark the template parameters. But this time, we're
3463 looking for the template parameters of the main
3464 template, not in the specialization. */
3465 tpd2
.current_arg
= i
;
3466 tpd2
.arg_uses_template_parms
[i
] = 0;
3467 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
3468 for_each_template_parm (type
,
3469 &mark_template_parm
,
3472 /*include_nondeduced_p=*/false);
3474 if (tpd2
.arg_uses_template_parms
[i
])
3476 /* The type depended on some template parameters.
3477 If they are fully specialized in the
3478 specialization, that's OK. */
3480 for (j
= 0; j
< nargs
; ++j
)
3481 if (tpd2
.parms
[j
] != 0
3482 && tpd
.arg_uses_template_parms
[j
])
3484 error ("type %qT of template argument %qE depends "
3485 "on template parameter(s)",
3496 if (retrieve_specialization (maintmpl
, specargs
,
3497 /*class_specializations_p=*/true))
3498 /* We've already got this specialization. */
3501 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
3502 = tree_cons (specargs
, inner_parms
,
3503 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
3504 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
3508 /* Check that a template declaration's use of default arguments and
3509 parameter packs is not invalid. Here, PARMS are the template
3510 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3511 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3515 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3516 declaration (but not a definition); 1 indicates a declaration, 2
3517 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3518 emitted for extraneous default arguments.
3520 Returns TRUE if there were no errors found, FALSE otherwise. */
3523 check_default_tmpl_args (tree decl
, tree parms
, int is_primary
,
3524 int is_partial
, int is_friend_decl
)
3527 int last_level_to_check
;
3529 bool no_errors
= true;
3533 A default template-argument shall not be specified in a
3534 function template declaration or a function template definition, nor
3535 in the template-parameter-list of the definition of a member of a
3538 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
3539 /* You can't have a function template declaration in a local
3540 scope, nor you can you define a member of a class template in a
3544 if (current_class_type
3545 && !TYPE_BEING_DEFINED (current_class_type
)
3546 && DECL_LANG_SPECIFIC (decl
)
3547 /* If this is either a friend defined in the scope of the class
3548 or a member function. */
3549 && (DECL_FUNCTION_MEMBER_P (decl
)
3550 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
3551 : DECL_FRIEND_CONTEXT (decl
)
3552 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
3554 /* And, if it was a member function, it really was defined in
3555 the scope of the class. */
3556 && (!DECL_FUNCTION_MEMBER_P (decl
)
3557 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
3558 /* We already checked these parameters when the template was
3559 declared, so there's no need to do it again now. This function
3560 was defined in class scope, but we're processing it's body now
3561 that the class is complete. */
3564 /* Core issue 226 (C++0x only): the following only applies to class
3566 if ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
)
3570 If a template-parameter has a default template-argument, all
3571 subsequent template-parameters shall have a default
3572 template-argument supplied. */
3573 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
3575 tree inner_parms
= TREE_VALUE (parm_level
);
3576 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
3577 int seen_def_arg_p
= 0;
3580 for (i
= 0; i
< ntparms
; ++i
)
3582 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
3584 if (parm
== error_mark_node
)
3587 if (TREE_PURPOSE (parm
))
3589 else if (seen_def_arg_p
)
3591 error ("no default argument for %qD", TREE_VALUE (parm
));
3592 /* For better subsequent error-recovery, we indicate that
3593 there should have been a default argument. */
3594 TREE_PURPOSE (parm
) = error_mark_node
;
3600 && TREE_CODE (decl
) == TYPE_DECL
3602 && template_parameter_pack_p (TREE_VALUE (parm
)))
3604 /* A primary class template can only have one
3605 parameter pack, at the end of the template
3608 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
)
3609 error ("parameter pack %qE must be at the end of the"
3610 " template parameter list", TREE_VALUE (parm
));
3612 error ("parameter pack %qT must be at the end of the"
3613 " template parameter list",
3614 TREE_TYPE (TREE_VALUE (parm
)));
3616 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
3624 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
3628 /* For an ordinary class template, default template arguments are
3629 allowed at the innermost level, e.g.:
3630 template <class T = int>
3632 but, in a partial specialization, they're not allowed even
3633 there, as we have in [temp.class.spec]:
3635 The template parameter list of a specialization shall not
3636 contain default template argument values.
3638 So, for a partial specialization, or for a function template
3639 (in C++98/C++03), we look at all of them. */
3642 /* But, for a primary class template that is not a partial
3643 specialization we look at all template parameters except the
3645 parms
= TREE_CHAIN (parms
);
3647 /* Figure out what error message to issue. */
3648 if (is_friend_decl
== 2)
3649 msg
= "default template arguments may not be used in function template friend re-declaration";
3650 else if (is_friend_decl
)
3651 msg
= "default template arguments may not be used in function template friend declarations";
3652 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
3653 msg
= "default template arguments may not be used in function templates";
3654 else if (is_partial
)
3655 msg
= "default template arguments may not be used in partial specializations";
3657 msg
= "default argument for template parameter for class enclosing %qD";
3659 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
3660 /* If we're inside a class definition, there's no need to
3661 examine the parameters to the class itself. On the one
3662 hand, they will be checked when the class is defined, and,
3663 on the other, default arguments are valid in things like:
3664 template <class T = double>
3665 struct S { template <class U> void f(U); };
3666 Here the default argument for `S' has no bearing on the
3667 declaration of `f'. */
3668 last_level_to_check
= template_class_depth (current_class_type
) + 1;
3670 /* Check everything. */
3671 last_level_to_check
= 0;
3673 for (parm_level
= parms
;
3674 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
3675 parm_level
= TREE_CHAIN (parm_level
))
3677 tree inner_parms
= TREE_VALUE (parm_level
);
3681 ntparms
= TREE_VEC_LENGTH (inner_parms
);
3682 for (i
= 0; i
< ntparms
; ++i
)
3684 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
3687 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
3692 if (is_friend_decl
== 2)
3699 /* Clear out the default argument so that we are not
3701 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
3705 /* At this point, if we're still interested in issuing messages,
3706 they must apply to classes surrounding the object declared. */
3708 msg
= "default argument for template parameter for class enclosing %qD";
3714 /* Worker for push_template_decl_real, called via
3715 for_each_template_parm. DATA is really an int, indicating the
3716 level of the parameters we are interested in. If T is a template
3717 parameter of that level, return nonzero. */
3720 template_parm_this_level_p (tree t
, void* data
)
3722 int this_level
= *(int *)data
;
3725 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
3726 level
= TEMPLATE_PARM_LEVEL (t
);
3728 level
= TEMPLATE_TYPE_LEVEL (t
);
3729 return level
== this_level
;
3732 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3733 parameters given by current_template_args, or reuses a
3734 previously existing one, if appropriate. Returns the DECL, or an
3735 equivalent one, if it is replaced via a call to duplicate_decls.
3737 If IS_FRIEND is true, DECL is a friend declaration. */
3740 push_template_decl_real (tree decl
, bool is_friend
)
3748 int new_template_p
= 0;
3749 /* True if the template is a member template, in the sense of
3751 bool member_template_p
= false;
3753 if (decl
== error_mark_node
)
3756 /* See if this is a partial specialization. */
3757 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
3758 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
3759 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
3761 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
3765 /* For a friend, we want the context of the friend function, not
3766 the type of which it is a friend. */
3767 ctx
= DECL_CONTEXT (decl
);
3768 else if (CP_DECL_CONTEXT (decl
)
3769 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
3770 /* In the case of a virtual function, we want the class in which
3772 ctx
= CP_DECL_CONTEXT (decl
);
3774 /* Otherwise, if we're currently defining some class, the DECL
3775 is assumed to be a member of the class. */
3776 ctx
= current_scope ();
3778 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
3781 if (!DECL_CONTEXT (decl
))
3782 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
3784 /* See if this is a primary template. */
3785 if (is_friend
&& ctx
)
3786 /* A friend template that specifies a class context, i.e.
3787 template <typename T> friend void A<T>::f();
3791 primary
= template_parm_scope_p ();
3795 if (DECL_CLASS_SCOPE_P (decl
))
3796 member_template_p
= true;
3797 if (TREE_CODE (decl
) == TYPE_DECL
3798 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
3799 error ("template class without a name");
3800 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3802 if (DECL_DESTRUCTOR_P (decl
))
3806 A destructor shall not be a member template. */
3807 error ("destructor %qD declared as member template", decl
);
3808 return error_mark_node
;
3810 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl
))
3811 && (!TYPE_ARG_TYPES (TREE_TYPE (decl
))
3812 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
3813 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
3814 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl
))))
3815 == void_list_node
)))
3817 /* [basic.stc.dynamic.allocation]
3819 An allocation function can be a function
3820 template. ... Template allocation functions shall
3821 have two or more parameters. */
3822 error ("invalid template declaration of %qD", decl
);
3823 return error_mark_node
;
3826 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
3827 && CLASS_TYPE_P (TREE_TYPE (decl
)))
3831 error ("template declaration of %q#D", decl
);
3832 return error_mark_node
;
3836 /* Check to see that the rules regarding the use of default
3837 arguments are not being violated. */
3838 check_default_tmpl_args (decl
, current_template_parms
,
3839 primary
, is_partial
, /*is_friend_decl=*/0);
3841 /* Ensure that there are no parameter packs in the type of this
3842 declaration that have not been expanded. */
3843 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3845 /* Check each of the arguments individually to see if there are
3846 any bare parameter packs. */
3847 tree type
= TREE_TYPE (decl
);
3848 tree arg
= DECL_ARGUMENTS (decl
);
3849 tree argtype
= TYPE_ARG_TYPES (type
);
3851 while (arg
&& argtype
)
3853 if (!FUNCTION_PARAMETER_PACK_P (arg
)
3854 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
3856 /* This is a PARM_DECL that contains unexpanded parameter
3857 packs. We have already complained about this in the
3858 check_for_bare_parameter_packs call, so just replace
3859 these types with ERROR_MARK_NODE. */
3860 TREE_TYPE (arg
) = error_mark_node
;
3861 TREE_VALUE (argtype
) = error_mark_node
;
3864 arg
= TREE_CHAIN (arg
);
3865 argtype
= TREE_CHAIN (argtype
);
3868 /* Check for bare parameter packs in the return type and the
3869 exception specifiers. */
3870 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
3871 /* Errors were already issued, set return type to int
3872 as the frontend doesn't expect error_mark_node as
3874 TREE_TYPE (type
) = integer_type_node
;
3875 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
3876 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
3878 else if (check_for_bare_parameter_packs (TREE_TYPE (decl
)))
3880 TREE_TYPE (decl
) = error_mark_node
;
3881 return error_mark_node
;
3885 return process_partial_specialization (decl
);
3887 args
= current_template_args ();
3890 || TREE_CODE (ctx
) == FUNCTION_DECL
3891 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
3892 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
3894 if (DECL_LANG_SPECIFIC (decl
)
3895 && DECL_TEMPLATE_INFO (decl
)
3896 && DECL_TI_TEMPLATE (decl
))
3897 tmpl
= DECL_TI_TEMPLATE (decl
);
3898 /* If DECL is a TYPE_DECL for a class-template, then there won't
3899 be DECL_LANG_SPECIFIC. The information equivalent to
3900 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3901 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
3902 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
3903 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
3905 /* Since a template declaration already existed for this
3906 class-type, we must be redeclaring it here. Make sure
3907 that the redeclaration is valid. */
3908 redeclare_class_template (TREE_TYPE (decl
),
3909 current_template_parms
);
3910 /* We don't need to create a new TEMPLATE_DECL; just use the
3911 one we already had. */
3912 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
3916 tmpl
= build_template_decl (decl
, current_template_parms
,
3920 if (DECL_LANG_SPECIFIC (decl
)
3921 && DECL_TEMPLATE_SPECIALIZATION (decl
))
3923 /* A specialization of a member template of a template
3925 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
3926 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
3927 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
3933 tree a
, t
, current
, parms
;
3935 tree tinfo
= get_template_info (decl
);
3939 error ("template definition of non-template %q#D", decl
);
3940 return error_mark_node
;
3943 tmpl
= TI_TEMPLATE (tinfo
);
3945 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
3946 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
3947 && DECL_TEMPLATE_SPECIALIZATION (decl
)
3948 && DECL_MEMBER_TEMPLATE_P (tmpl
))
3952 /* The declaration is a specialization of a member
3953 template, declared outside the class. Therefore, the
3954 innermost template arguments will be NULL, so we
3955 replace them with the arguments determined by the
3956 earlier call to check_explicit_specialization. */
3957 args
= DECL_TI_ARGS (decl
);
3960 = build_template_decl (decl
, current_template_parms
,
3962 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
3963 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
3964 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
3965 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
3966 DECL_TEMPLATE_INFO (new_tmpl
)
3967 = tree_cons (tmpl
, args
, NULL_TREE
);
3969 register_specialization (new_tmpl
,
3970 most_general_template (tmpl
),
3976 /* Make sure the template headers we got make sense. */
3978 parms
= DECL_TEMPLATE_PARMS (tmpl
);
3979 i
= TMPL_PARMS_DEPTH (parms
);
3980 if (TMPL_ARGS_DEPTH (args
) != i
)
3982 error ("expected %d levels of template parms for %q#D, got %d",
3983 i
, decl
, TMPL_ARGS_DEPTH (args
));
3986 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
3988 a
= TMPL_ARGS_LEVEL (args
, i
);
3989 t
= INNERMOST_TEMPLATE_PARMS (parms
);
3991 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
3993 if (current
== decl
)
3994 error ("got %d template parameters for %q#D",
3995 TREE_VEC_LENGTH (a
), decl
);
3997 error ("got %d template parameters for %q#T",
3998 TREE_VEC_LENGTH (a
), current
);
3999 error (" but %d required", TREE_VEC_LENGTH (t
));
4000 return error_mark_node
;
4003 if (current
== decl
)
4006 current
= (TYPE_P (current
)
4007 ? TYPE_CONTEXT (current
)
4008 : DECL_CONTEXT (current
));
4011 /* Check that the parms are used in the appropriate qualifying scopes
4012 in the declarator. */
4013 if (!comp_template_args
4015 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
4018 template arguments to %qD do not match original template %qD",
4019 decl
, DECL_TEMPLATE_RESULT (tmpl
));
4020 if (!uses_template_parms (TI_ARGS (tinfo
)))
4021 inform ("use template<> for an explicit specialization");
4022 /* Avoid crash in import_export_decl. */
4023 DECL_INTERFACE_KNOWN (decl
) = 1;
4024 return error_mark_node
;
4028 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4029 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
4031 /* Push template declarations for global functions and types. Note
4032 that we do not try to push a global template friend declared in a
4033 template class; such a thing may well depend on the template
4034 parameters of the class. */
4035 if (new_template_p
&& !ctx
4036 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
4038 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
4039 if (tmpl
== error_mark_node
)
4040 return error_mark_node
;
4042 /* Hide template friend classes that haven't been declared yet. */
4043 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
4045 DECL_ANTICIPATED (tmpl
) = 1;
4046 DECL_FRIEND_P (tmpl
) = 1;
4052 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
4055 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
4056 if (DECL_CONV_FN_P (tmpl
))
4058 int depth
= TMPL_PARMS_DEPTH (parms
);
4060 /* It is a conversion operator. See if the type converted to
4061 depends on innermost template operands. */
4063 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl
)),
4065 DECL_TEMPLATE_CONV_FN_P (tmpl
) = 1;
4068 /* Give template template parms a DECL_CONTEXT of the template
4069 for which they are a parameter. */
4070 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4071 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
4073 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4074 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
4075 DECL_CONTEXT (parm
) = tmpl
;
4079 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4080 back to its most general template. If TMPL is a specialization,
4081 ARGS may only have the innermost set of arguments. Add the missing
4082 argument levels if necessary. */
4083 if (DECL_TEMPLATE_INFO (tmpl
))
4084 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
4086 info
= tree_cons (tmpl
, args
, NULL_TREE
);
4088 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
4089 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
4090 else if (DECL_LANG_SPECIFIC (decl
))
4091 DECL_TEMPLATE_INFO (decl
) = info
;
4093 return DECL_TEMPLATE_RESULT (tmpl
);
4097 push_template_decl (tree decl
)
4099 return push_template_decl_real (decl
, false);
4102 /* Called when a class template TYPE is redeclared with the indicated
4103 template PARMS, e.g.:
4105 template <class T> struct S;
4106 template <class T> struct S {}; */
4109 redeclare_class_template (tree type
, tree parms
)
4115 if (!TYPE_TEMPLATE_INFO (type
))
4117 error ("%qT is not a template type", type
);
4121 tmpl
= TYPE_TI_TEMPLATE (type
);
4122 if (!PRIMARY_TEMPLATE_P (tmpl
))
4123 /* The type is nested in some template class. Nothing to worry
4124 about here; there are no new template parameters for the nested
4130 error ("template specifiers not specified in declaration of %qD",
4135 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
4136 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
4138 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
4140 error ("redeclared with %d template parameter(s)",
4141 TREE_VEC_LENGTH (parms
));
4142 inform ("previous declaration %q+D used %d template parameter(s)",
4143 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
4147 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
4154 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
4155 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
4158 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
4159 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
4160 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
4161 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
4163 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4165 if (tmpl_parm
!= error_mark_node
4166 && (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
4167 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
4168 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
4169 || (TREE_CODE (tmpl_parm
) != PARM_DECL
4170 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
4171 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
4172 || (TREE_CODE (tmpl_parm
) == PARM_DECL
4173 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
4174 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))))))
4176 error ("template parameter %q+#D", tmpl_parm
);
4177 error ("redeclared here as %q#D", parm
);
4181 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
4183 /* We have in [temp.param]:
4185 A template-parameter may not be given default arguments
4186 by two different declarations in the same scope. */
4187 error ("redefinition of default argument for %q#D", parm
);
4188 inform ("%Joriginal definition appeared here", tmpl_parm
);
4192 if (parm_default
!= NULL_TREE
)
4193 /* Update the previous template parameters (which are the ones
4194 that will really count) with the new default value. */
4195 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
4196 else if (tmpl_default
!= NULL_TREE
)
4197 /* Update the new parameters, too; they'll be used as the
4198 parameters for any members. */
4199 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
4205 /* Simplify EXPR if it is a non-dependent expression. Returns the
4206 (possibly simplified) expression. */
4209 fold_non_dependent_expr (tree expr
)
4211 if (expr
== NULL_TREE
)
4214 /* If we're in a template, but EXPR isn't value dependent, simplify
4215 it. We're supposed to treat:
4217 template <typename T> void f(T[1 + 1]);
4218 template <typename T> void f(T[2]);
4220 as two declarations of the same function, for example. */
4221 if (processing_template_decl
4222 && !type_dependent_expression_p (expr
)
4223 && !value_dependent_expression_p (expr
))
4225 HOST_WIDE_INT saved_processing_template_decl
;
4227 saved_processing_template_decl
= processing_template_decl
;
4228 processing_template_decl
= 0;
4229 expr
= tsubst_copy_and_build (expr
,
4232 /*in_decl=*/NULL_TREE
,
4233 /*function_p=*/false,
4234 /*integral_constant_expression_p=*/true);
4235 processing_template_decl
= saved_processing_template_decl
;
4240 /* EXPR is an expression which is used in a constant-expression context.
4241 For instance, it could be a VAR_DECL with a constant initializer.
4242 Extract the innest constant expression.
4244 This is basically a more powerful version of
4245 integral_constant_value, which can be used also in templates where
4246 initializers can maintain a syntactic rather than semantic form
4247 (even if they are non-dependent, for access-checking purposes). */
4250 fold_decl_constant_value (tree expr
)
4252 tree const_expr
= expr
;
4255 expr
= fold_non_dependent_expr (const_expr
);
4256 const_expr
= integral_constant_value (expr
);
4258 while (expr
!= const_expr
);
4263 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4264 must be a function or a pointer-to-function type, as specified
4265 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4266 and check that the resulting function has external linkage. */
4269 convert_nontype_argument_function (tree type
, tree expr
)
4274 fn
= instantiate_type (type
, fns
, tf_none
);
4275 if (fn
== error_mark_node
)
4276 return error_mark_node
;
4279 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
4280 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
4281 if (TREE_CODE (fn_no_ptr
) == BASELINK
)
4282 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
4284 /* [temp.arg.nontype]/1
4286 A template-argument for a non-type, non-template template-parameter
4289 -- the address of an object or function with external linkage. */
4290 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr
))
4292 error ("%qE is not a valid template argument for type %qT "
4293 "because function %qD has not external linkage",
4294 expr
, type
, fn_no_ptr
);
4301 /* Attempt to convert the non-type template parameter EXPR to the
4302 indicated TYPE. If the conversion is successful, return the
4303 converted value. If the conversion is unsuccessful, return
4304 NULL_TREE if we issued an error message, or error_mark_node if we
4305 did not. We issue error messages for out-and-out bad template
4306 parameters, but not simply because the conversion failed, since we
4307 might be just trying to do argument deduction. Both TYPE and EXPR
4308 must be non-dependent.
4310 The conversion follows the special rules described in
4311 [temp.arg.nontype], and it is much more strict than an implicit
4314 This function is called twice for each template argument (see
4315 lookup_template_class for a more accurate description of this
4316 problem). This means that we need to handle expressions which
4317 are not valid in a C++ source, but can be created from the
4318 first call (for instance, casts to perform conversions). These
4319 hacks can go away after we fix the double coercion problem. */
4322 convert_nontype_argument (tree type
, tree expr
)
4326 /* Detect immediately string literals as invalid non-type argument.
4327 This special-case is not needed for correctness (we would easily
4328 catch this later), but only to provide better diagnostic for this
4329 common user mistake. As suggested by DR 100, we do not mention
4330 linkage issues in the diagnostic as this is not the point. */
4331 if (TREE_CODE (expr
) == STRING_CST
)
4333 error ("%qE is not a valid template argument for type %qT "
4334 "because string literals can never be used in this context",
4339 /* If we are in a template, EXPR may be non-dependent, but still
4340 have a syntactic, rather than semantic, form. For example, EXPR
4341 might be a SCOPE_REF, rather than the VAR_DECL to which the
4342 SCOPE_REF refers. Preserving the qualifying scope is necessary
4343 so that access checking can be performed when the template is
4344 instantiated -- but here we need the resolved form so that we can
4345 convert the argument. */
4346 expr
= fold_non_dependent_expr (expr
);
4347 if (error_operand_p (expr
))
4348 return error_mark_node
;
4349 expr_type
= TREE_TYPE (expr
);
4351 /* HACK: Due to double coercion, we can get a
4352 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4353 which is the tree that we built on the first call (see
4354 below when coercing to reference to object or to reference to
4355 function). We just strip everything and get to the arg.
4356 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4358 if (TREE_CODE (expr
) == NOP_EXPR
)
4360 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
4362 /* ??? Maybe we could use convert_from_reference here, but we
4363 would need to relax its constraints because the NOP_EXPR
4364 could actually change the type to something more cv-qualified,
4365 and this is not folded by convert_from_reference. */
4366 tree addr
= TREE_OPERAND (expr
, 0);
4367 gcc_assert (TREE_CODE (expr_type
) == REFERENCE_TYPE
);
4368 gcc_assert (TREE_CODE (addr
) == ADDR_EXPR
);
4369 gcc_assert (TREE_CODE (TREE_TYPE (addr
)) == POINTER_TYPE
);
4370 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4371 (TREE_TYPE (expr_type
),
4372 TREE_TYPE (TREE_TYPE (addr
))));
4374 expr
= TREE_OPERAND (addr
, 0);
4375 expr_type
= TREE_TYPE (expr
);
4378 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4379 parameter is a pointer to object, through decay and
4380 qualification conversion. Let's strip everything. */
4381 else if (TYPE_PTROBV_P (type
))
4384 gcc_assert (TREE_CODE (expr
) == ADDR_EXPR
);
4385 gcc_assert (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
);
4386 /* Skip the ADDR_EXPR only if it is part of the decay for
4387 an array. Otherwise, it is part of the original argument
4388 in the source code. */
4389 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == ARRAY_TYPE
)
4390 expr
= TREE_OPERAND (expr
, 0);
4391 expr_type
= TREE_TYPE (expr
);
4395 /* [temp.arg.nontype]/5, bullet 1
4397 For a non-type template-parameter of integral or enumeration type,
4398 integral promotions (_conv.prom_) and integral conversions
4399 (_conv.integral_) are applied. */
4400 if (INTEGRAL_TYPE_P (type
))
4402 if (!INTEGRAL_TYPE_P (expr_type
))
4403 return error_mark_node
;
4405 expr
= fold_decl_constant_value (expr
);
4406 /* Notice that there are constant expressions like '4 % 0' which
4407 do not fold into integer constants. */
4408 if (TREE_CODE (expr
) != INTEGER_CST
)
4410 error ("%qE is not a valid template argument for type %qT "
4411 "because it is a non-constant expression", expr
, type
);
4415 /* At this point, an implicit conversion does what we want,
4416 because we already know that the expression is of integral
4418 expr
= ocp_convert (type
, expr
, CONV_IMPLICIT
, LOOKUP_PROTECT
);
4419 if (expr
== error_mark_node
)
4420 return error_mark_node
;
4422 /* Conversion was allowed: fold it to a bare integer constant. */
4425 /* [temp.arg.nontype]/5, bullet 2
4427 For a non-type template-parameter of type pointer to object,
4428 qualification conversions (_conv.qual_) and the array-to-pointer
4429 conversion (_conv.array_) are applied. */
4430 else if (TYPE_PTROBV_P (type
))
4432 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4434 A template-argument for a non-type, non-template template-parameter
4435 shall be one of: [...]
4437 -- the name of a non-type template-parameter;
4438 -- the address of an object or function with external linkage, [...]
4439 expressed as "& id-expression" where the & is optional if the name
4440 refers to a function or array, or if the corresponding
4441 template-parameter is a reference.
4443 Here, we do not care about functions, as they are invalid anyway
4444 for a parameter of type pointer-to-object. */
4446 if (DECL_P (expr
) && DECL_TEMPLATE_PARM_P (expr
))
4447 /* Non-type template parameters are OK. */
4449 else if (TREE_CODE (expr
) != ADDR_EXPR
4450 && TREE_CODE (expr_type
) != ARRAY_TYPE
)
4452 if (TREE_CODE (expr
) == VAR_DECL
)
4454 error ("%qD is not a valid template argument "
4455 "because %qD is a variable, not the address of "
4460 /* Other values, like integer constants, might be valid
4461 non-type arguments of some other type. */
4462 return error_mark_node
;
4468 decl
= ((TREE_CODE (expr
) == ADDR_EXPR
)
4469 ? TREE_OPERAND (expr
, 0) : expr
);
4470 if (TREE_CODE (decl
) != VAR_DECL
)
4472 error ("%qE is not a valid template argument of type %qT "
4473 "because %qE is not a variable",
4477 else if (!DECL_EXTERNAL_LINKAGE_P (decl
))
4479 error ("%qE is not a valid template argument of type %qT "
4480 "because %qD does not have external linkage",
4486 expr
= decay_conversion (expr
);
4487 if (expr
== error_mark_node
)
4488 return error_mark_node
;
4490 expr
= perform_qualification_conversions (type
, expr
);
4491 if (expr
== error_mark_node
)
4492 return error_mark_node
;
4494 /* [temp.arg.nontype]/5, bullet 3
4496 For a non-type template-parameter of type reference to object, no
4497 conversions apply. The type referred to by the reference may be more
4498 cv-qualified than the (otherwise identical) type of the
4499 template-argument. The template-parameter is bound directly to the
4500 template-argument, which must be an lvalue. */
4501 else if (TYPE_REF_OBJ_P (type
))
4503 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
4505 return error_mark_node
;
4507 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
4509 error ("%qE is not a valid template argument for type %qT "
4510 "because of conflicts in cv-qualification", expr
, type
);
4514 if (!real_lvalue_p (expr
))
4516 error ("%qE is not a valid template argument for type %qT "
4517 "because it is not an lvalue", expr
, type
);
4521 /* [temp.arg.nontype]/1
4523 A template-argument for a non-type, non-template template-parameter
4524 shall be one of: [...]
4526 -- the address of an object or function with external linkage. */
4527 if (!DECL_EXTERNAL_LINKAGE_P (expr
))
4529 error ("%qE is not a valid template argument for type %qT "
4530 "because object %qD has not external linkage",
4535 expr
= build_nop (type
, build_address (expr
));
4537 /* [temp.arg.nontype]/5, bullet 4
4539 For a non-type template-parameter of type pointer to function, only
4540 the function-to-pointer conversion (_conv.func_) is applied. If the
4541 template-argument represents a set of overloaded functions (or a
4542 pointer to such), the matching function is selected from the set
4544 else if (TYPE_PTRFN_P (type
))
4546 /* If the argument is a template-id, we might not have enough
4547 context information to decay the pointer. */
4548 if (!type_unknown_p (expr_type
))
4550 expr
= decay_conversion (expr
);
4551 if (expr
== error_mark_node
)
4552 return error_mark_node
;
4555 expr
= convert_nontype_argument_function (type
, expr
);
4556 if (!expr
|| expr
== error_mark_node
)
4559 if (TREE_CODE (expr
) != ADDR_EXPR
)
4561 error ("%qE is not a valid template argument for type %qT", expr
, type
);
4562 error ("it must be the address of a function with external linkage");
4566 /* [temp.arg.nontype]/5, bullet 5
4568 For a non-type template-parameter of type reference to function, no
4569 conversions apply. If the template-argument represents a set of
4570 overloaded functions, the matching function is selected from the set
4572 else if (TYPE_REFFN_P (type
))
4574 if (TREE_CODE (expr
) == ADDR_EXPR
)
4576 error ("%qE is not a valid template argument for type %qT "
4577 "because it is a pointer", expr
, type
);
4578 inform ("try using %qE instead", TREE_OPERAND (expr
, 0));
4582 expr
= convert_nontype_argument_function (TREE_TYPE (type
), expr
);
4583 if (!expr
|| expr
== error_mark_node
)
4586 expr
= build_nop (type
, build_address (expr
));
4588 /* [temp.arg.nontype]/5, bullet 6
4590 For a non-type template-parameter of type pointer to member function,
4591 no conversions apply. If the template-argument represents a set of
4592 overloaded member functions, the matching member function is selected
4593 from the set (_over.over_). */
4594 else if (TYPE_PTRMEMFUNC_P (type
))
4596 expr
= instantiate_type (type
, expr
, tf_none
);
4597 if (expr
== error_mark_node
)
4598 return error_mark_node
;
4600 /* There is no way to disable standard conversions in
4601 resolve_address_of_overloaded_function (called by
4602 instantiate_type). It is possible that the call succeeded by
4603 converting &B::I to &D::I (where B is a base of D), so we need
4604 to reject this conversion here.
4606 Actually, even if there was a way to disable standard conversions,
4607 it would still be better to reject them here so that we can
4608 provide a superior diagnostic. */
4609 if (!same_type_p (TREE_TYPE (expr
), type
))
4611 /* Make sure we are just one standard conversion off. */
4612 gcc_assert (can_convert (type
, TREE_TYPE (expr
)));
4613 error ("%qE is not a valid template argument for type %qT "
4614 "because it is of type %qT", expr
, type
,
4616 inform ("standard conversions are not allowed in this context");
4620 /* [temp.arg.nontype]/5, bullet 7
4622 For a non-type template-parameter of type pointer to data member,
4623 qualification conversions (_conv.qual_) are applied. */
4624 else if (TYPE_PTRMEM_P (type
))
4626 expr
= perform_qualification_conversions (type
, expr
);
4627 if (expr
== error_mark_node
)
4630 /* A template non-type parameter must be one of the above. */
4634 /* Sanity check: did we actually convert the argument to the
4636 gcc_assert (same_type_p (type
, TREE_TYPE (expr
)));
4641 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4642 template template parameters. Both PARM_PARMS and ARG_PARMS are
4643 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4646 Consider the example:
4647 template <class T> class A;
4648 template<template <class U> class TT> class B;
4650 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4651 the parameters to A, and OUTER_ARGS contains A. */
4654 coerce_template_template_parms (tree parm_parms
,
4656 tsubst_flags_t complain
,
4660 int nparms
, nargs
, i
;
4663 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
4664 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
4666 nparms
= TREE_VEC_LENGTH (parm_parms
);
4667 nargs
= TREE_VEC_LENGTH (arg_parms
);
4669 if (nargs
!= nparms
)
4672 for (i
= 0; i
< nparms
; ++i
)
4674 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
4675 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
4678 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
4679 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
4681 if (arg
== NULL_TREE
|| arg
== error_mark_node
4682 || parm
== NULL_TREE
|| parm
== error_mark_node
)
4685 if (TREE_CODE (arg
) != TREE_CODE (parm
))
4688 switch (TREE_CODE (parm
))
4691 /* We encounter instantiations of templates like
4692 template <template <template <class> class> class TT>
4695 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
4696 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
4698 if (!coerce_template_template_parms
4699 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
4705 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))
4706 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
)))
4707 /* One is a parameter pack, the other is not. */
4712 /* The tsubst call is used to handle cases such as
4714 template <int> class C {};
4715 template <class T, template <T> class TT> class D {};
4718 i.e. the parameter list of TT depends on earlier parameters. */
4719 if (!uses_template_parms (TREE_TYPE (arg
))
4721 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
4725 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4726 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
)))
4727 /* One is a parameter pack, the other is not. */
4738 /* Verifies that the deduced template arguments (in TARGS) for the
4739 template template parameters (in TPARMS) represent valid bindings,
4740 by comparing the template parameter list of each template argument
4741 to the template parameter list of its corresponding template
4742 template parameter, in accordance with DR150. This
4743 routine can only be called after all template arguments have been
4744 deduced. It will return TRUE if all of the template template
4745 parameter bindings are okay, FALSE otherwise. */
4747 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
4749 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
4752 /* We're dealing with template parms in this process. */
4753 ++processing_template_decl
;
4755 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
4757 for (i
= 0; i
< ntparms
; ++i
)
4759 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
4760 tree targ
= TREE_VEC_ELT (targs
, i
);
4762 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
4764 tree packed_args
= NULL_TREE
;
4767 if (ARGUMENT_PACK_P (targ
))
4769 /* Look inside the argument pack. */
4770 packed_args
= ARGUMENT_PACK_ARGS (targ
);
4771 len
= TREE_VEC_LENGTH (packed_args
);
4774 for (idx
= 0; idx
< len
; ++idx
)
4776 tree targ_parms
= NULL_TREE
;
4779 /* Extract the next argument from the argument
4781 targ
= TREE_VEC_ELT (packed_args
, idx
);
4783 if (PACK_EXPANSION_P (targ
))
4784 /* Look at the pattern of the pack expansion. */
4785 targ
= PACK_EXPANSION_PATTERN (targ
);
4787 /* Extract the template parameters from the template
4789 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
4790 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
4791 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
4792 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
4794 /* Verify that we can coerce the template template
4795 parameters from the template argument to the template
4796 parameter. This requires an exact match. */
4798 && !coerce_template_template_parms
4799 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
4814 --processing_template_decl
;
4818 /* Convert the indicated template ARG as necessary to match the
4819 indicated template PARM. Returns the converted ARG, or
4820 error_mark_node if the conversion was unsuccessful. Error and
4821 warning messages are issued under control of COMPLAIN. This
4822 conversion is for the Ith parameter in the parameter list. ARGS is
4823 the full set of template arguments deduced so far. */
4826 convert_template_argument (tree parm
,
4829 tsubst_flags_t complain
,
4835 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
4837 if (TREE_CODE (arg
) == TREE_LIST
4838 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
4840 /* The template argument was the name of some
4841 member function. That's usually
4842 invalid, but static members are OK. In any
4843 case, grab the underlying fields/functions
4844 and issue an error later if required. */
4845 orig_arg
= TREE_VALUE (arg
);
4846 TREE_TYPE (arg
) = unknown_type_node
;
4851 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
4852 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
4853 || requires_tmpl_type
);
4855 /* When determining whether an argument pack expansion is a template,
4856 look at the pattern. */
4857 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
4858 arg
= PACK_EXPANSION_PATTERN (arg
);
4861 ((TREE_CODE (arg
) == TEMPLATE_DECL
4862 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
4863 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4864 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
4867 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4868 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
4869 arg
= TYPE_STUB_DECL (arg
);
4871 is_type
= TYPE_P (arg
) || is_tmpl_type
;
4873 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
4874 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
4876 pedwarn ("to refer to a type member of a template parameter, "
4877 "use %<typename %E%>", orig_arg
);
4879 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
4880 TREE_OPERAND (arg
, 1),
4882 complain
& tf_error
);
4886 if (is_type
!= requires_type
)
4890 if (complain
& tf_error
)
4892 error ("type/value mismatch at argument %d in template "
4893 "parameter list for %qD",
4896 error (" expected a constant of type %qT, got %qT",
4898 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
4899 else if (requires_tmpl_type
)
4900 error (" expected a class template, got %qE", orig_arg
);
4902 error (" expected a type, got %qE", orig_arg
);
4905 return error_mark_node
;
4907 if (is_tmpl_type
^ requires_tmpl_type
)
4909 if (in_decl
&& (complain
& tf_error
))
4911 error ("type/value mismatch at argument %d in template "
4912 "parameter list for %qD",
4915 error (" expected a type, got %qT", DECL_NAME (arg
));
4917 error (" expected a class template, got %qT", orig_arg
);
4919 return error_mark_node
;
4924 if (requires_tmpl_type
)
4926 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
4927 /* The number of argument required is not known yet.
4928 Just accept it for now. */
4929 val
= TREE_TYPE (arg
);
4932 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
4935 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
4937 if (coerce_template_template_parms (parmparm
, argparm
,
4943 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4945 if (val
!= error_mark_node
)
4947 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
4948 val
= TREE_TYPE (val
);
4949 else if (TREE_CODE (val
) == TYPE_PACK_EXPANSION
4950 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg
))
4952 val
= TREE_TYPE (arg
);
4953 val
= make_pack_expansion (val
);
4959 if (in_decl
&& (complain
& tf_error
))
4961 error ("type/value mismatch at argument %d in "
4962 "template parameter list for %qD",
4964 error (" expected a template of type %qD, got %qD",
4968 val
= error_mark_node
;
4974 /* We only form one instance of each template specialization.
4975 Therefore, if we use a non-canonical variant (i.e., a
4976 typedef), any future messages referring to the type will use
4977 the typedef, which is confusing if those future uses do not
4978 themselves also use the typedef. */
4980 val
= canonical_type_variant (val
);
4984 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
4986 if (invalid_nontype_parm_type_p (t
, complain
))
4987 return error_mark_node
;
4989 if (!uses_template_parms (orig_arg
) && !uses_template_parms (t
))
4990 /* We used to call digest_init here. However, digest_init
4991 will report errors, which we don't want when complain
4992 is zero. More importantly, digest_init will try too
4993 hard to convert things: for example, `0' should not be
4994 converted to pointer type at this point according to
4995 the standard. Accepting this is not merely an
4996 extension, since deciding whether or not these
4997 conversions can occur is part of determining which
4998 function template to call, or whether a given explicit
4999 argument specification is valid. */
5000 val
= convert_nontype_argument (t
, orig_arg
);
5004 if (val
== NULL_TREE
)
5005 val
= error_mark_node
;
5006 else if (val
== error_mark_node
&& (complain
& tf_error
))
5007 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
5013 /* Coerces the remaining template arguments in INNER_ARGS (from
5014 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5015 Returns the coerced argument pack. PARM_IDX is the position of this
5016 parameter in the template parameter list. ARGS is the original
5017 template argument list. */
5019 coerce_template_parameter_pack (tree parms
,
5027 tsubst_flags_t complain
)
5029 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
5030 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
5033 tree packed_types
= NULL_TREE
;
5035 if (arg_idx
> nargs
)
5038 packed_args
= make_tree_vec (nargs
- arg_idx
);
5040 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
5041 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm
))))
5043 /* When the template parameter is a non-type template
5044 parameter pack whose type uses parameter packs, we need
5045 to look at each of the template arguments
5046 separately. Build a vector of the types for these
5047 non-type template parameters in PACKED_TYPES. */
5049 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm
)));
5050 packed_types
= tsubst_pack_expansion (expansion
, args
,
5053 if (packed_types
== error_mark_node
)
5054 return error_mark_node
;
5056 /* Check that we have the right number of arguments. */
5058 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
))
5059 && nargs
- arg_idx
!= TREE_VEC_LENGTH (packed_types
))
5062 = TREE_VEC_LENGTH (parms
) - 1 + TREE_VEC_LENGTH (packed_types
);
5063 error ("wrong number of template arguments (%d, should be %d)",
5064 nargs
, needed_parms
);
5065 return error_mark_node
;
5068 /* If we aren't able to check the actual arguments now
5069 (because they haven't been expanded yet), we can at least
5070 verify that all of the types used for the non-type
5071 template parameter pack are, in fact, valid for non-type
5072 template parameters. */
5074 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
5076 int j
, len
= TREE_VEC_LENGTH (packed_types
);
5077 for (j
= 0; j
< len
; ++j
)
5079 tree t
= TREE_VEC_ELT (packed_types
, j
);
5080 if (invalid_nontype_parm_type_p (t
, complain
))
5081 return error_mark_node
;
5086 /* Convert the remaining arguments, which will be a part of the
5087 parameter pack "parm". */
5088 for (; arg_idx
< nargs
; ++arg_idx
)
5090 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
5091 tree actual_parm
= TREE_VALUE (parm
);
5093 if (packed_types
&& !PACK_EXPANSION_P (arg
))
5095 /* When we have a vector of types (corresponding to the
5096 non-type template parameter pack that uses parameter
5097 packs in its type, as mention above), and the
5098 argument is not an expansion (which expands to a
5099 currently unknown number of arguments), clone the
5100 parm and give it the next type in PACKED_TYPES. */
5101 actual_parm
= copy_node (actual_parm
);
5102 TREE_TYPE (actual_parm
) =
5103 TREE_VEC_ELT (packed_types
, arg_idx
- parm_idx
);
5106 if (arg
!= error_mark_node
)
5107 arg
= convert_template_argument (actual_parm
,
5108 arg
, new_args
, complain
, parm_idx
,
5110 if (arg
== error_mark_node
)
5112 TREE_VEC_ELT (packed_args
, arg_idx
- parm_idx
) = arg
;
5115 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
5116 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
5117 argument_pack
= make_node (TYPE_ARGUMENT_PACK
);
5120 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
5121 TREE_TYPE (argument_pack
)
5122 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
5123 TREE_CONSTANT (argument_pack
) = 1;
5126 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
5127 return argument_pack
;
5130 /* Convert all template arguments to their appropriate types, and
5131 return a vector containing the innermost resulting template
5132 arguments. If any error occurs, return error_mark_node. Error and
5133 warning messages are issued under control of COMPLAIN.
5135 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5136 for arguments not specified in ARGS. Otherwise, if
5137 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5138 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5139 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5143 coerce_template_parms (tree parms
,
5146 tsubst_flags_t complain
,
5147 bool require_all_args
,
5148 bool use_default_args
)
5150 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
5153 tree new_inner_args
;
5154 bool saved_skip_evaluation
;
5156 /* When used as a boolean value, indicates whether this is a
5157 variadic template parameter list. Since it's an int, we can also
5158 subtract it from nparms to get the number of non-variadic
5163 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args
));
5165 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
5166 nparms
= TREE_VEC_LENGTH (parms
);
5168 /* Determine if there are any parameter packs. */
5169 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
5171 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
5172 if (template_parameter_pack_p (tparm
))
5179 if ((nargs
> nparms
- variadic_p
&& !variadic_p
)
5180 || (nargs
< nparms
- variadic_p
5182 && (!use_default_args
5183 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
5184 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
5186 if (complain
& tf_error
)
5188 const char *or_more
= "";
5191 or_more
= " or more";
5195 error ("wrong number of template arguments (%d, should be %d%s)",
5196 nargs
, nparms
, or_more
);
5199 error ("provided for %q+D", in_decl
);
5202 return error_mark_node
;
5205 /* We need to evaluate the template arguments, even though this
5206 template-id may be nested within a "sizeof". */
5207 saved_skip_evaluation
= skip_evaluation
;
5208 skip_evaluation
= false;
5209 new_inner_args
= make_tree_vec (nparms
);
5210 new_args
= add_outermost_template_args (args
, new_inner_args
);
5211 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
5216 /* Get the Ith template parameter. */
5217 parm
= TREE_VEC_ELT (parms
, parm_idx
);
5219 if (parm
== error_mark_node
)
5221 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
5225 /* Calculate the next argument. */
5226 if (template_parameter_pack_p (TREE_VALUE (parm
)))
5228 /* All remaining arguments will be placed in the
5229 template parameter pack PARM. */
5230 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
5231 inner_args
, arg_idx
,
5235 /* Store this argument. */
5236 if (arg
== error_mark_node
)
5238 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
5240 /* We are done with all of the arguments. */
5245 else if (arg_idx
< nargs
)
5247 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
5249 if (arg
&& PACK_EXPANSION_P (arg
))
5251 if (complain
& tf_error
)
5253 /* If ARG is a pack expansion, but PARM is not a
5254 template parameter pack (if it were, we would have
5255 handled it above), we're trying to expand into a
5256 fixed-length argument list. */
5257 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
5258 error ("cannot expand %<%E%> into a fixed-length "
5259 "argument list", arg
);
5261 error ("cannot expand %<%T%> into a fixed-length "
5262 "argument list", arg
);
5264 return error_mark_node
;
5267 else if (require_all_args
)
5268 /* There must be a default arg in this case. */
5269 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
5274 if (arg
== error_mark_node
)
5276 if (complain
& tf_error
)
5277 error ("template argument %d is invalid", arg_idx
+ 1);
5280 /* This only occurs if there was an error in the template
5281 parameter list itself (which we would already have
5282 reported) that we are trying to recover from, e.g., a class
5283 template with a parameter list such as
5284 template<typename..., typename>. */
5285 return error_mark_node
;
5287 arg
= convert_template_argument (TREE_VALUE (parm
),
5288 arg
, new_args
, complain
,
5291 if (arg
== error_mark_node
)
5293 TREE_VEC_ELT (new_inner_args
, arg_idx
) = arg
;
5295 skip_evaluation
= saved_skip_evaluation
;
5298 return error_mark_node
;
5300 return new_inner_args
;
5303 /* Returns 1 if template args OT and NT are equivalent. */
5306 template_args_equal (tree ot
, tree nt
)
5311 if (TREE_CODE (nt
) == TREE_VEC
)
5312 /* For member templates */
5313 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
5314 else if (PACK_EXPANSION_P (ot
))
5315 return PACK_EXPANSION_P (nt
)
5316 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
5317 PACK_EXPANSION_PATTERN (nt
));
5318 else if (TYPE_P (nt
))
5319 return TYPE_P (ot
) && same_type_p (ot
, nt
);
5320 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
5323 return cp_tree_equal (ot
, nt
);
5326 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5327 of template arguments. Returns 0 otherwise. */
5330 comp_template_args (tree oldargs
, tree newargs
)
5334 oldargs
= expand_template_argument_pack (oldargs
);
5335 newargs
= expand_template_argument_pack (newargs
);
5337 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
5340 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
5342 tree nt
= TREE_VEC_ELT (newargs
, i
);
5343 tree ot
= TREE_VEC_ELT (oldargs
, i
);
5345 if (! template_args_equal (ot
, nt
))
5352 add_pending_template (tree d
)
5354 tree ti
= (TYPE_P (d
)
5355 ? CLASSTYPE_TEMPLATE_INFO (d
)
5356 : DECL_TEMPLATE_INFO (d
));
5357 struct pending_template
*pt
;
5360 if (TI_PENDING_TEMPLATE_FLAG (ti
))
5363 /* We are called both from instantiate_decl, where we've already had a
5364 tinst_level pushed, and instantiate_template, where we haven't.
5366 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
5369 push_tinst_level (d
);
5371 pt
= GGC_NEW (struct pending_template
);
5373 pt
->tinst
= current_tinst_level
;
5374 if (last_pending_template
)
5375 last_pending_template
->next
= pt
;
5377 pending_templates
= pt
;
5379 last_pending_template
= pt
;
5381 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
5388 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5389 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5390 documentation for TEMPLATE_ID_EXPR. */
5393 lookup_template_function (tree fns
, tree arglist
)
5397 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
5398 return error_mark_node
;
5400 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
5401 gcc_assert (fns
&& (is_overloaded_fn (fns
)
5402 || TREE_CODE (fns
) == IDENTIFIER_NODE
));
5404 if (BASELINK_P (fns
))
5406 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
5408 BASELINK_FUNCTIONS (fns
),
5413 type
= TREE_TYPE (fns
);
5414 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
5415 type
= unknown_type_node
;
5417 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
5420 /* Within the scope of a template class S<T>, the name S gets bound
5421 (in build_self_reference) to a TYPE_DECL for the class, not a
5422 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5423 or one of its enclosing classes, and that type is a template,
5424 return the associated TEMPLATE_DECL. Otherwise, the original
5425 DECL is returned. */
5428 maybe_get_template_decl_from_type_decl (tree decl
)
5430 return (decl
!= NULL_TREE
5431 && TREE_CODE (decl
) == TYPE_DECL
5432 && DECL_ARTIFICIAL (decl
)
5433 && CLASS_TYPE_P (TREE_TYPE (decl
))
5434 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
5435 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
5438 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5439 parameters, find the desired type.
5441 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5443 IN_DECL, if non-NULL, is the template declaration we are trying to
5446 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5447 the class we are looking up.
5449 Issue error and warning messages under control of COMPLAIN.
5451 If the template class is really a local class in a template
5452 function, then the FUNCTION_CONTEXT is the function in which it is
5455 ??? Note that this function is currently called *twice* for each
5456 template-id: the first time from the parser, while creating the
5457 incomplete type (finish_template_type), and the second type during the
5458 real instantiation (instantiate_template_class). This is surely something
5459 that we want to avoid. It also causes some problems with argument
5460 coercion (see convert_nontype_argument for more information on this). */
5463 lookup_template_class (tree d1
,
5468 tsubst_flags_t complain
)
5470 tree
template = NULL_TREE
, parmlist
;
5473 timevar_push (TV_NAME_LOOKUP
);
5475 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
5477 tree value
= innermost_non_namespace_value (d1
);
5478 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
5483 push_decl_namespace (context
);
5484 template = lookup_name (d1
);
5485 template = maybe_get_template_decl_from_type_decl (template);
5487 pop_decl_namespace ();
5490 context
= DECL_CONTEXT (template);
5492 else if (TREE_CODE (d1
) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (d1
)))
5494 tree type
= TREE_TYPE (d1
);
5496 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5497 an implicit typename for the second A. Deal with it. */
5498 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5499 type
= TREE_TYPE (type
);
5501 if (CLASSTYPE_TEMPLATE_INFO (type
))
5503 template = CLASSTYPE_TI_TEMPLATE (type
);
5504 d1
= DECL_NAME (template);
5507 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
5508 || (TYPE_P (d1
) && IS_AGGR_TYPE (d1
)))
5510 template = TYPE_TI_TEMPLATE (d1
);
5511 d1
= DECL_NAME (template);
5513 else if (TREE_CODE (d1
) == TEMPLATE_DECL
5514 && DECL_TEMPLATE_RESULT (d1
)
5515 && TREE_CODE (DECL_TEMPLATE_RESULT (d1
)) == TYPE_DECL
)
5518 d1
= DECL_NAME (template);
5519 context
= DECL_CONTEXT (template);
5522 /* Issue an error message if we didn't find a template. */
5525 if (complain
& tf_error
)
5526 error ("%qT is not a template", d1
);
5527 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5530 if (TREE_CODE (template) != TEMPLATE_DECL
5531 /* Make sure it's a user visible template, if it was named by
5533 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (template)
5534 && !PRIMARY_TEMPLATE_P (template)))
5536 if (complain
& tf_error
)
5538 error ("non-template type %qT used as a template", d1
);
5540 error ("for template declaration %q+D", in_decl
);
5542 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5545 complain
&= ~tf_user
;
5547 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
5549 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5550 template arguments */
5556 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
5558 /* Consider an example where a template template parameter declared as
5560 template <class T, class U = std::allocator<T> > class TT
5562 The template parameter level of T and U are one level larger than
5563 of TT. To proper process the default argument of U, say when an
5564 instantiation `TT<int>' is seen, we need to build the full
5565 arguments containing {int} as the innermost level. Outer levels,
5566 available when not appearing as default template argument, can be
5567 obtained from the arguments of the enclosing template.
5569 Suppose that TT is later substituted with std::vector. The above
5570 instantiation is `TT<int, std::allocator<T> >' with TT at
5571 level 1, and T at level 2, while the template arguments at level 1
5572 becomes {std::vector} and the inner level 2 is {int}. */
5574 outer
= DECL_CONTEXT (template);
5576 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
5577 else if (current_template_parms
)
5578 /* This is an argument of the current template, so we haven't set
5579 DECL_CONTEXT yet. */
5580 outer
= current_template_args ();
5583 arglist
= add_to_template_args (outer
, arglist
);
5585 arglist2
= coerce_template_parms (parmlist
, arglist
, template,
5587 /*require_all_args=*/true,
5588 /*use_default_args=*/true);
5589 if (arglist2
== error_mark_node
5590 || (!uses_template_parms (arglist2
)
5591 && check_instantiated_args (template, arglist2
, complain
)))
5592 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5594 parm
= bind_template_template_parm (TREE_TYPE (template), arglist2
);
5595 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, parm
);
5599 tree template_type
= TREE_TYPE (template);
5602 tree found
= NULL_TREE
;
5605 int is_partial_instantiation
;
5607 gen_tmpl
= most_general_template (template);
5608 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
5609 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
5610 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
5612 if (arg_depth
== 1 && parm_depth
> 1)
5614 /* We've been given an incomplete set of template arguments.
5617 template <class T> struct S1 {
5618 template <class U> struct S2 {};
5619 template <class U> struct S2<U*> {};
5622 we will be called with an ARGLIST of `U*', but the
5623 TEMPLATE will be `template <class T> template
5624 <class U> struct S1<T>::S2'. We must fill in the missing
5627 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
5629 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
5632 /* Now we should have enough arguments. */
5633 gcc_assert (parm_depth
== arg_depth
);
5635 /* From here on, we're only interested in the most general
5637 template = gen_tmpl
;
5639 /* Calculate the BOUND_ARGS. These will be the args that are
5640 actually tsubst'd into the definition to create the
5644 /* We have multiple levels of arguments to coerce, at once. */
5646 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
5648 tree bound_args
= make_tree_vec (parm_depth
);
5650 for (i
= saved_depth
,
5651 t
= DECL_TEMPLATE_PARMS (template);
5652 i
> 0 && t
!= NULL_TREE
;
5653 --i
, t
= TREE_CHAIN (t
))
5655 tree a
= coerce_template_parms (TREE_VALUE (t
),
5658 /*require_all_args=*/true,
5659 /*use_default_args=*/true);
5661 /* Don't process further if one of the levels fails. */
5662 if (a
== error_mark_node
)
5664 /* Restore the ARGLIST to its full size. */
5665 TREE_VEC_LENGTH (arglist
) = saved_depth
;
5666 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5669 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
5671 /* We temporarily reduce the length of the ARGLIST so
5672 that coerce_template_parms will see only the arguments
5673 corresponding to the template parameters it is
5675 TREE_VEC_LENGTH (arglist
)--;
5678 /* Restore the ARGLIST to its full size. */
5679 TREE_VEC_LENGTH (arglist
) = saved_depth
;
5681 arglist
= bound_args
;
5685 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
5686 INNERMOST_TEMPLATE_ARGS (arglist
),
5689 /*require_all_args=*/true,
5690 /*use_default_args=*/true);
5692 if (arglist
== error_mark_node
)
5693 /* We were unable to bind the arguments. */
5694 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5696 /* In the scope of a template class, explicit references to the
5697 template class refer to the type of the template, not any
5698 instantiation of it. For example, in:
5700 template <class T> class C { void f(C<T>); }
5702 the `C<T>' is just the same as `C'. Outside of the
5703 class, however, such a reference is an instantiation. */
5704 if (comp_template_args (TYPE_TI_ARGS (template_type
),
5707 found
= template_type
;
5709 if (!entering_scope
&& PRIMARY_TEMPLATE_P (template))
5713 for (ctx
= current_class_type
;
5714 ctx
&& TREE_CODE (ctx
) != NAMESPACE_DECL
;
5716 ? TYPE_CONTEXT (ctx
)
5717 : DECL_CONTEXT (ctx
)))
5718 if (TYPE_P (ctx
) && same_type_p (ctx
, template_type
))
5721 /* We're not in the scope of the class, so the
5722 TEMPLATE_TYPE is not the type we want after all. */
5728 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5730 /* If we already have this specialization, return it. */
5731 found
= retrieve_specialization (template, arglist
,
5732 /*class_specializations_p=*/false);
5734 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5736 /* This type is a "partial instantiation" if any of the template
5737 arguments still involve template parameters. Note that we set
5738 IS_PARTIAL_INSTANTIATION for partial specializations as
5740 is_partial_instantiation
= uses_template_parms (arglist
);
5742 /* If the deduced arguments are invalid, then the binding
5744 if (!is_partial_instantiation
5745 && check_instantiated_args (template,
5746 INNERMOST_TEMPLATE_ARGS (arglist
),
5748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5750 if (!is_partial_instantiation
5751 && !PRIMARY_TEMPLATE_P (template)
5752 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL
)
5754 found
= xref_tag_from_type (TREE_TYPE (template),
5755 DECL_NAME (template),
5756 /*tag_scope=*/ts_global
);
5757 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5760 context
= tsubst (DECL_CONTEXT (template), arglist
,
5763 context
= global_namespace
;
5765 /* Create the type. */
5766 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
5768 if (!is_partial_instantiation
)
5770 set_current_access_from_decl (TYPE_NAME (template_type
));
5771 t
= start_enum (TYPE_IDENTIFIER (template_type
));
5774 /* We don't want to call start_enum for this type, since
5775 the values for the enumeration constants may involve
5776 template parameters. And, no one should be interested
5777 in the enumeration constants for such a type. */
5778 t
= make_node (ENUMERAL_TYPE
);
5782 t
= make_aggr_type (TREE_CODE (template_type
));
5783 CLASSTYPE_DECLARED_CLASS (t
)
5784 = CLASSTYPE_DECLARED_CLASS (template_type
);
5785 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
5786 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
5788 /* A local class. Make sure the decl gets registered properly. */
5789 if (context
== current_function_decl
)
5790 pushtag (DECL_NAME (template), t
, /*tag_scope=*/ts_current
);
5792 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
5793 /* This instantiation is another name for the primary
5794 template type. Set the TYPE_CANONICAL field
5796 TYPE_CANONICAL (t
) = template_type
;
5797 else if (any_template_arguments_need_structural_equality_p (arglist
))
5798 /* Some of the template arguments require structural
5799 equality testing, so this template class requires
5800 structural equality testing. */
5801 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5804 /* If we called start_enum or pushtag above, this information
5805 will already be set up. */
5808 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5810 type_decl
= create_implicit_typedef (DECL_NAME (template), t
);
5811 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
5812 TYPE_STUB_DECL (t
) = type_decl
;
5813 DECL_SOURCE_LOCATION (type_decl
)
5814 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
5817 type_decl
= TYPE_NAME (t
);
5819 TREE_PRIVATE (type_decl
)
5820 = TREE_PRIVATE (TYPE_STUB_DECL (template_type
));
5821 TREE_PROTECTED (type_decl
)
5822 = TREE_PROTECTED (TYPE_STUB_DECL (template_type
));
5823 DECL_IN_SYSTEM_HEADER (type_decl
)
5824 = DECL_IN_SYSTEM_HEADER (template);
5825 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
5827 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
5828 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
5831 /* Set up the template information. We have to figure out which
5832 template is the immediate parent if this is a full
5834 if (parm_depth
== 1 || is_partial_instantiation
5835 || !PRIMARY_TEMPLATE_P (template))
5836 /* This case is easy; there are no member templates involved. */
5840 /* This is a full instantiation of a member template. Look
5841 for a partial instantiation of which this is an instance. */
5843 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
5844 found
; found
= TREE_CHAIN (found
))
5847 tree tmpl
= CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found
));
5849 /* We only want partial instantiations, here, not
5850 specializations or full instantiations. */
5851 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found
))
5852 || !uses_template_parms (TREE_VALUE (found
)))
5855 /* Temporarily reduce by one the number of levels in the
5856 ARGLIST and in FOUND so as to avoid comparing the
5857 last set of arguments. */
5858 TREE_VEC_LENGTH (arglist
)--;
5859 TREE_VEC_LENGTH (TREE_PURPOSE (found
)) --;
5861 /* See if the arguments match. If they do, then TMPL is
5862 the partial instantiation we want. */
5863 success
= comp_template_args (TREE_PURPOSE (found
), arglist
);
5865 /* Restore the argument vectors to their full size. */
5866 TREE_VEC_LENGTH (arglist
)++;
5867 TREE_VEC_LENGTH (TREE_PURPOSE (found
))++;
5878 /* There was no partial instantiation. This happens
5879 where C<T> is a member template of A<T> and it's used
5882 template <typename T> struct B { A<T>::C<int> m; };
5885 Create the partial instantiation.
5887 TREE_VEC_LENGTH (arglist
)--;
5888 found
= tsubst (template, arglist
, complain
, NULL_TREE
);
5889 TREE_VEC_LENGTH (arglist
)++;
5893 SET_TYPE_TEMPLATE_INFO (t
, tree_cons (found
, arglist
, NULL_TREE
));
5894 DECL_TEMPLATE_INSTANTIATIONS (template)
5895 = tree_cons (arglist
, t
,
5896 DECL_TEMPLATE_INSTANTIATIONS (template));
5898 if (TREE_CODE (t
) == ENUMERAL_TYPE
5899 && !is_partial_instantiation
)
5900 /* Now that the type has been registered on the instantiations
5901 list, we set up the enumerators. Because the enumeration
5902 constants may involve the enumeration type itself, we make
5903 sure to register the type first, and then create the
5904 constants. That way, doing tsubst_expr for the enumeration
5905 constants won't result in recursive calls here; we'll find
5906 the instantiation and exit above. */
5907 tsubst_enum (template_type
, t
, arglist
);
5909 if (is_partial_instantiation
)
5910 /* If the type makes use of template parameters, the
5911 code that generates debugging information will crash. */
5912 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
5914 /* Possibly limit visibility based on template args. */
5915 TREE_PUBLIC (type_decl
) = 1;
5916 determine_visibility (type_decl
);
5918 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
5920 timevar_pop (TV_NAME_LOOKUP
);
5927 /* True when we should also visit template parameters that occur in
5928 non-deduced contexts. */
5929 bool include_nondeduced_p
;
5930 struct pointer_set_t
*visited
;
5933 /* Called from for_each_template_parm via walk_tree. */
5936 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
5939 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
5940 tree_fn_t fn
= pfd
->fn
;
5941 void *data
= pfd
->data
;
5944 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
5945 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
5946 pfd
->include_nondeduced_p
))
5947 return error_mark_node
;
5949 switch (TREE_CODE (t
))
5952 if (TYPE_PTRMEMFUNC_P (t
))
5958 if (!TYPE_TEMPLATE_INFO (t
))
5960 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t
)),
5961 fn
, data
, pfd
->visited
,
5962 pfd
->include_nondeduced_p
))
5963 return error_mark_node
;
5967 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
5968 fn
, data
, pfd
->visited
,
5969 pfd
->include_nondeduced_p
)
5970 || for_each_template_parm (TYPE_MAX_VALUE (t
),
5971 fn
, data
, pfd
->visited
,
5972 pfd
->include_nondeduced_p
))
5973 return error_mark_node
;
5977 /* Since we're not going to walk subtrees, we have to do this
5979 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
5980 pfd
->visited
, pfd
->include_nondeduced_p
))
5981 return error_mark_node
;
5985 /* Check the return type. */
5986 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
5987 pfd
->include_nondeduced_p
))
5988 return error_mark_node
;
5990 /* Check the parameter types. Since default arguments are not
5991 instantiated until they are needed, the TYPE_ARG_TYPES may
5992 contain expressions that involve template parameters. But,
5993 no-one should be looking at them yet. And, once they're
5994 instantiated, they don't contain template parameters, so
5995 there's no point in looking at them then, either. */
5999 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
6000 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
6001 pfd
->visited
, pfd
->include_nondeduced_p
))
6002 return error_mark_node
;
6004 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6005 want walk_tree walking into them itself. */
6011 if (pfd
->include_nondeduced_p
6012 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
6014 pfd
->include_nondeduced_p
))
6015 return error_mark_node
;
6020 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
6021 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
6022 pfd
->visited
, pfd
->include_nondeduced_p
))
6023 return error_mark_node
;
6028 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
6029 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
6030 pfd
->visited
, pfd
->include_nondeduced_p
))
6031 return error_mark_node
;
6032 if (DECL_CONTEXT (t
)
6033 && pfd
->include_nondeduced_p
6034 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
6035 pfd
->visited
, pfd
->include_nondeduced_p
))
6036 return error_mark_node
;
6039 case BOUND_TEMPLATE_TEMPLATE_PARM
:
6040 /* Record template parameters such as `T' inside `TT<T>'. */
6041 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
6042 pfd
->include_nondeduced_p
))
6043 return error_mark_node
;
6046 case TEMPLATE_TEMPLATE_PARM
:
6047 case TEMPLATE_TYPE_PARM
:
6048 case TEMPLATE_PARM_INDEX
:
6049 if (fn
&& (*fn
)(t
, data
))
6050 return error_mark_node
;
6052 return error_mark_node
;
6056 /* A template template parameter is encountered. */
6057 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
6058 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
6059 pfd
->include_nondeduced_p
))
6060 return error_mark_node
;
6062 /* Already substituted template template parameter */
6068 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
6070 pfd
->include_nondeduced_p
))
6071 return error_mark_node
;
6075 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
6076 && pfd
->include_nondeduced_p
6077 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6078 (TREE_TYPE (t
)), fn
, data
,
6079 pfd
->visited
, pfd
->include_nondeduced_p
))
6080 return error_mark_node
;
6085 /* If there's no type, then this thing must be some expression
6086 involving template parameters. */
6087 if (!fn
&& !TREE_TYPE (t
))
6088 return error_mark_node
;
6093 case REINTERPRET_CAST_EXPR
:
6094 case CONST_CAST_EXPR
:
6095 case STATIC_CAST_EXPR
:
6096 case DYNAMIC_CAST_EXPR
:
6100 case PSEUDO_DTOR_EXPR
:
6102 return error_mark_node
;
6109 /* We didn't find any template parameters we liked. */
6113 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6114 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6115 call FN with the parameter and the DATA.
6116 If FN returns nonzero, the iteration is terminated, and
6117 for_each_template_parm returns 1. Otherwise, the iteration
6118 continues. If FN never returns a nonzero value, the value
6119 returned by for_each_template_parm is 0. If FN is NULL, it is
6120 considered to be the function which always returns 1.
6122 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6123 parameters that occur in non-deduced contexts. When false, only
6124 visits those template parameters that can be deduced. */
6127 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
6128 struct pointer_set_t
*visited
,
6129 bool include_nondeduced_p
)
6131 struct pair_fn_data pfd
;
6137 pfd
.include_nondeduced_p
= include_nondeduced_p
;
6139 /* Walk the tree. (Conceptually, we would like to walk without
6140 duplicates, but for_each_template_parm_r recursively calls
6141 for_each_template_parm, so we would need to reorganize a fair
6142 bit to use walk_tree_without_duplicates, so we keep our own
6145 pfd
.visited
= visited
;
6147 pfd
.visited
= pointer_set_create ();
6148 result
= cp_walk_tree (&t
,
6149 for_each_template_parm_r
,
6151 pfd
.visited
) != NULL_TREE
;
6156 pointer_set_destroy (pfd
.visited
);
6163 /* Returns true if T depends on any template parameter. */
6166 uses_template_parms (tree t
)
6169 int saved_processing_template_decl
;
6171 saved_processing_template_decl
= processing_template_decl
;
6172 if (!saved_processing_template_decl
)
6173 processing_template_decl
= 1;
6175 dependent_p
= dependent_type_p (t
);
6176 else if (TREE_CODE (t
) == TREE_VEC
)
6177 dependent_p
= any_dependent_template_arguments_p (t
);
6178 else if (TREE_CODE (t
) == TREE_LIST
)
6179 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
6180 || uses_template_parms (TREE_CHAIN (t
)));
6181 else if (TREE_CODE (t
) == TYPE_DECL
)
6182 dependent_p
= dependent_type_p (TREE_TYPE (t
));
6185 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
6186 || TREE_CODE (t
) == OVERLOAD
6187 || TREE_CODE (t
) == BASELINK
6188 || TREE_CODE (t
) == IDENTIFIER_NODE
6189 || TREE_CODE (t
) == TRAIT_EXPR
6190 || CONSTANT_CLASS_P (t
))
6191 dependent_p
= (type_dependent_expression_p (t
)
6192 || value_dependent_expression_p (t
));
6195 gcc_assert (t
== error_mark_node
);
6196 dependent_p
= false;
6199 processing_template_decl
= saved_processing_template_decl
;
6204 /* Returns true if T depends on any template parameter with level LEVEL. */
6207 uses_template_parms_level (tree t
, int level
)
6209 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
6210 /*include_nondeduced_p=*/true);
6213 static int tinst_depth
;
6214 extern int max_tinst_depth
;
6215 #ifdef GATHER_STATISTICS
6218 static int tinst_level_tick
;
6219 static int last_template_error_tick
;
6221 /* We're starting to instantiate D; record the template instantiation context
6222 for diagnostics and to restore it later. */
6225 push_tinst_level (tree d
)
6227 struct tinst_level
*new;
6229 if (tinst_depth
>= max_tinst_depth
)
6231 /* If the instantiation in question still has unbound template parms,
6232 we don't really care if we can't instantiate it, so just return.
6233 This happens with base instantiation for implicit `typename'. */
6234 if (uses_template_parms (d
))
6237 last_template_error_tick
= tinst_level_tick
;
6238 error ("template instantiation depth exceeds maximum of %d (use "
6239 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6240 max_tinst_depth
, d
);
6242 print_instantiation_context ();
6247 new = GGC_NEW (struct tinst_level
);
6249 new->locus
= input_location
;
6250 new->in_system_header_p
= in_system_header
;
6251 new->next
= current_tinst_level
;
6252 current_tinst_level
= new;
6255 #ifdef GATHER_STATISTICS
6256 if (tinst_depth
> depth_reached
)
6257 depth_reached
= tinst_depth
;
6264 /* We're done instantiating this template; return to the instantiation
6268 pop_tinst_level (void)
6270 /* Restore the filename and line number stashed away when we started
6271 this instantiation. */
6272 input_location
= current_tinst_level
->locus
;
6273 in_system_header
= current_tinst_level
->in_system_header_p
;
6274 current_tinst_level
= current_tinst_level
->next
;
6279 /* We're instantiating a deferred template; restore the template
6280 instantiation context in which the instantiation was requested, which
6281 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6284 reopen_tinst_level (struct tinst_level
*level
)
6286 struct tinst_level
*t
;
6289 for (t
= level
; t
; t
= t
->next
)
6292 current_tinst_level
= level
;
6297 /* Returns the TINST_LEVEL which gives the original instantiation
6300 struct tinst_level
*
6301 outermost_tinst_level (void)
6303 struct tinst_level
*level
= current_tinst_level
;
6306 level
= level
->next
;
6310 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
6313 parameter_of_template_p (tree parm
, tree templ
)
6318 if (!parm
|| !templ
)
6321 gcc_assert (DECL_TEMPLATE_PARM_P (parm
));
6322 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
6324 parms
= DECL_TEMPLATE_PARMS (templ
);
6325 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
6327 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
6328 if (parm
== TREE_VALUE (TREE_VEC_ELT (parms
, i
)))
6334 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6335 vector of template arguments, as for tsubst.
6337 Returns an appropriate tsubst'd friend declaration. */
6340 tsubst_friend_function (tree decl
, tree args
)
6344 if (TREE_CODE (decl
) == FUNCTION_DECL
6345 && DECL_TEMPLATE_INSTANTIATION (decl
)
6346 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
6347 /* This was a friend declared with an explicit template
6348 argument list, e.g.:
6352 to indicate that f was a template instantiation, not a new
6353 function declaration. Now, we have to figure out what
6354 instantiation of what template. */
6356 tree template_id
, arglist
, fns
;
6359 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
6361 /* Friend functions are looked up in the containing namespace scope.
6362 We must enter that scope, to avoid finding member functions of the
6363 current cless with same name. */
6364 push_nested_namespace (ns
);
6365 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
6366 tf_warning_or_error
, NULL_TREE
,
6367 /*integral_constant_expression_p=*/false);
6368 pop_nested_namespace (ns
);
6369 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
6370 tf_warning_or_error
, NULL_TREE
);
6371 template_id
= lookup_template_function (fns
, arglist
);
6373 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
6374 tmpl
= determine_specialization (template_id
, new_friend
,
6376 /*need_member_template=*/0,
6377 TREE_VEC_LENGTH (args
),
6379 return instantiate_template (tmpl
, new_args
, tf_error
);
6382 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
6384 /* The NEW_FRIEND will look like an instantiation, to the
6385 compiler, but is not an instantiation from the point of view of
6386 the language. For example, we might have had:
6388 template <class T> struct S {
6389 template <class U> friend void f(T, U);
6392 Then, in S<int>, template <class U> void f(int, U) is not an
6393 instantiation of anything. */
6394 if (new_friend
== error_mark_node
)
6395 return error_mark_node
;
6397 DECL_USE_TEMPLATE (new_friend
) = 0;
6398 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
6400 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
6401 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
6402 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
6405 /* The mangled name for the NEW_FRIEND is incorrect. The function
6406 is not a template instantiation and should not be mangled like
6407 one. Therefore, we forget the mangling here; we'll recompute it
6408 later if we need it. */
6409 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
6411 SET_DECL_RTL (new_friend
, NULL_RTX
);
6412 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
6415 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
6418 tree new_friend_template_info
;
6419 tree new_friend_result_template_info
;
6421 int new_friend_is_defn
;
6423 /* We must save some information from NEW_FRIEND before calling
6424 duplicate decls since that function will free NEW_FRIEND if
6426 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
6427 new_friend_is_defn
=
6428 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6429 (template_for_substitution (new_friend
)))
6431 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
6433 /* This declaration is a `primary' template. */
6434 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
6436 new_friend_result_template_info
6437 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
6440 new_friend_result_template_info
= NULL_TREE
;
6442 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6443 if (new_friend_is_defn
)
6444 DECL_INITIAL (new_friend
) = error_mark_node
;
6446 /* Inside pushdecl_namespace_level, we will push into the
6447 current namespace. However, the friend function should go
6448 into the namespace of the template. */
6449 ns
= decl_namespace_context (new_friend
);
6450 push_nested_namespace (ns
);
6451 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
6452 pop_nested_namespace (ns
);
6454 if (old_decl
== error_mark_node
)
6455 return error_mark_node
;
6457 if (old_decl
!= new_friend
)
6459 /* This new friend declaration matched an existing
6460 declaration. For example, given:
6462 template <class T> void f(T);
6463 template <class U> class C {
6464 template <class T> friend void f(T) {}
6467 the friend declaration actually provides the definition
6468 of `f', once C has been instantiated for some type. So,
6469 old_decl will be the out-of-class template declaration,
6470 while new_friend is the in-class definition.
6472 But, if `f' was called before this point, the
6473 instantiation of `f' will have DECL_TI_ARGS corresponding
6474 to `T' but not to `U', references to which might appear
6475 in the definition of `f'. Previously, the most general
6476 template for an instantiation of `f' was the out-of-class
6477 version; now it is the in-class version. Therefore, we
6478 run through all specialization of `f', adding to their
6479 DECL_TI_ARGS appropriately. In particular, they need a
6480 new set of outer arguments, corresponding to the
6481 arguments for this class instantiation.
6483 The same situation can arise with something like this:
6486 template <class T> class C {
6490 when `C<int>' is instantiated. Now, `f(int)' is defined
6493 if (!new_friend_is_defn
)
6494 /* On the other hand, if the in-class declaration does
6495 *not* provide a definition, then we don't want to alter
6496 existing definitions. We can just leave everything
6501 /* Overwrite whatever template info was there before, if
6502 any, with the new template information pertaining to
6504 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
6506 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
6507 reregister_specialization (new_friend
,
6508 most_general_template (old_decl
),
6513 tree new_friend_args
;
6515 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
6516 = new_friend_result_template_info
;
6518 new_friend_args
= TI_ARGS (new_friend_template_info
);
6519 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (old_decl
);
6523 tree spec
= TREE_VALUE (t
);
6526 = add_outermost_template_args (new_friend_args
,
6527 DECL_TI_ARGS (spec
));
6530 /* Now, since specializations are always supposed to
6531 hang off of the most general template, we must move
6533 t
= most_general_template (old_decl
);
6536 DECL_TEMPLATE_SPECIALIZATIONS (t
)
6537 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t
),
6538 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
));
6539 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
) = NULL_TREE
;
6544 /* The information from NEW_FRIEND has been merged into OLD_DECL
6545 by duplicate_decls. */
6546 new_friend
= old_decl
;
6551 tree context
= DECL_CONTEXT (new_friend
);
6555 template <class T> class C {
6556 template <class U> friend void C1<U>::f (); // case 1
6557 friend void C2<T>::f (); // case 2
6559 we only need to make sure CONTEXT is a complete type for
6560 case 2. To distinguish between the two cases, we note that
6561 CONTEXT of case 1 remains dependent type after tsubst while
6562 this isn't true for case 2. */
6563 ++processing_template_decl
;
6564 dependent_p
= dependent_type_p (context
);
6565 --processing_template_decl
;
6568 && !complete_type_or_else (context
, NULL_TREE
))
6569 return error_mark_node
;
6571 if (COMPLETE_TYPE_P (context
))
6573 /* Check to see that the declaration is really present, and,
6574 possibly obtain an improved declaration. */
6575 tree fn
= check_classfn (context
,
6576 new_friend
, NULL_TREE
);
6586 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6587 template arguments, as for tsubst.
6589 Returns an appropriate tsubst'd friend type or error_mark_node on
6593 tsubst_friend_class (tree friend_tmpl
, tree args
)
6599 context
= DECL_CONTEXT (friend_tmpl
);
6603 if (TREE_CODE (context
) == NAMESPACE_DECL
)
6604 push_nested_namespace (context
);
6606 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
6609 /* Look for a class template declaration. We look for hidden names
6610 because two friend declarations of the same template are the
6611 same. For example, in:
6614 template <typename> friend class F;
6616 template <typename> struct B {
6617 template <typename> friend class F;
6620 both F templates are the same. */
6621 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
6622 /*block_p=*/true, 0,
6623 LOOKUP_COMPLAIN
| LOOKUP_HIDDEN
);
6625 /* But, if we don't find one, it might be because we're in a
6626 situation like this:
6634 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6635 for `S<int>', not the TEMPLATE_DECL. */
6636 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
6638 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
6639 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
6642 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
6644 /* The friend template has already been declared. Just
6645 check to see that the declarations match, and install any new
6646 default parameters. We must tsubst the default parameters,
6647 of course. We only need the innermost template parameters
6648 because that is all that redeclare_class_template will look
6650 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
6651 > TMPL_ARGS_DEPTH (args
))
6654 location_t saved_input_location
;
6655 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
6656 args
, tf_warning_or_error
);
6658 saved_input_location
= input_location
;
6659 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
6660 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
6661 input_location
= saved_input_location
;
6665 friend_type
= TREE_TYPE (tmpl
);
6669 /* The friend template has not already been declared. In this
6670 case, the instantiation of the template class will cause the
6671 injection of this template into the global scope. */
6672 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
6673 if (tmpl
== error_mark_node
)
6674 return error_mark_node
;
6676 /* The new TMPL is not an instantiation of anything, so we
6677 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6678 the new type because that is supposed to be the corresponding
6679 template decl, i.e., TMPL. */
6680 DECL_USE_TEMPLATE (tmpl
) = 0;
6681 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
6682 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
6683 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
6684 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
6686 /* Inject this template into the global scope. */
6687 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
6692 if (TREE_CODE (context
) == NAMESPACE_DECL
)
6693 pop_nested_namespace (context
);
6695 pop_nested_class ();
6701 /* Returns zero if TYPE cannot be completed later due to circularity.
6702 Otherwise returns one. */
6705 can_complete_type_without_circularity (tree type
)
6707 if (type
== NULL_TREE
|| type
== error_mark_node
)
6709 else if (COMPLETE_TYPE_P (type
))
6711 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
6712 return can_complete_type_without_circularity (TREE_TYPE (type
));
6713 else if (CLASS_TYPE_P (type
)
6714 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
6720 /* Apply any attributes which had to be deferred until instantiation
6721 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6722 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6725 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
6726 tree args
, tsubst_flags_t complain
, tree in_decl
)
6728 tree last_dep
= NULL_TREE
;
6732 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
6733 if (ATTR_IS_DEPENDENT (t
))
6736 attributes
= copy_list (attributes
);
6740 if (DECL_P (*decl_p
))
6742 if (TREE_TYPE (*decl_p
) == error_mark_node
)
6744 p
= &DECL_ATTRIBUTES (*decl_p
);
6747 p
= &TYPE_ATTRIBUTES (*decl_p
);
6751 tree late_attrs
= NULL_TREE
;
6752 tree
*q
= &late_attrs
;
6754 for (*p
= attributes
; *p
; )
6757 if (ATTR_IS_DEPENDENT (t
))
6759 *p
= TREE_CHAIN (t
);
6760 TREE_CHAIN (t
) = NULL_TREE
;
6761 /* If the first attribute argument is an identifier, don't
6762 pass it through tsubst. Attributes like mode, format,
6763 cleanup and several target specific attributes expect it
6766 && TREE_CODE (TREE_VALUE (t
)) == TREE_LIST
6767 && TREE_VALUE (TREE_VALUE (t
))
6768 && (TREE_CODE (TREE_VALUE (TREE_VALUE (t
)))
6769 == IDENTIFIER_NODE
))
6772 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
6774 /*integral_constant_expression_p=*/false);
6775 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
6777 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
6782 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
6783 /*integral_constant_expression_p=*/false);
6785 q
= &TREE_CHAIN (t
);
6788 p
= &TREE_CHAIN (t
);
6791 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
6796 instantiate_class_template (tree type
)
6798 tree
template, args
, pattern
, t
, member
;
6803 if (type
== error_mark_node
)
6804 return error_mark_node
;
6806 if (TYPE_BEING_DEFINED (type
)
6807 || COMPLETE_TYPE_P (type
)
6808 || dependent_type_p (type
))
6811 /* Figure out which template is being instantiated. */
6812 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
6813 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL
);
6815 /* Determine what specialization of the original template to
6817 t
= most_specialized_class (type
, template);
6818 if (t
== error_mark_node
)
6820 TYPE_BEING_DEFINED (type
) = 1;
6821 return error_mark_node
;
6825 /* This TYPE is actually an instantiation of a partial
6826 specialization. We replace the innermost set of ARGS with
6827 the arguments appropriate for substitution. For example,
6830 template <class T> struct S {};
6831 template <class T> struct S<T*> {};
6833 and supposing that we are instantiating S<int*>, ARGS will
6834 presently be {int*} -- but we need {int}. */
6835 pattern
= TREE_TYPE (t
);
6836 args
= TREE_PURPOSE (t
);
6840 pattern
= TREE_TYPE (template);
6841 args
= CLASSTYPE_TI_ARGS (type
);
6844 /* If the template we're instantiating is incomplete, then clearly
6845 there's nothing we can do. */
6846 if (!COMPLETE_TYPE_P (pattern
))
6849 /* If we've recursively instantiated too many templates, stop. */
6850 if (! push_tinst_level (type
))
6853 /* Now we're really doing the instantiation. Mark the type as in
6854 the process of being defined. */
6855 TYPE_BEING_DEFINED (type
) = 1;
6857 /* We may be in the middle of deferred access check. Disable
6859 push_deferring_access_checks (dk_no_deferred
);
6861 push_to_top_level ();
6863 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
6865 /* Set the input location to the template definition. This is needed
6866 if tsubsting causes an error. */
6867 typedecl
= TYPE_MAIN_DECL (type
);
6868 input_location
= DECL_SOURCE_LOCATION (typedecl
);
6869 in_system_header
= DECL_IN_SYSTEM_HEADER (typedecl
);
6871 TYPE_HAS_USER_CONSTRUCTOR (type
) = TYPE_HAS_USER_CONSTRUCTOR (pattern
);
6872 TYPE_HAS_NEW_OPERATOR (type
) = TYPE_HAS_NEW_OPERATOR (pattern
);
6873 TYPE_HAS_ARRAY_NEW_OPERATOR (type
) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern
);
6874 TYPE_GETS_DELETE (type
) = TYPE_GETS_DELETE (pattern
);
6875 TYPE_HAS_ASSIGN_REF (type
) = TYPE_HAS_ASSIGN_REF (pattern
);
6876 TYPE_HAS_CONST_ASSIGN_REF (type
) = TYPE_HAS_CONST_ASSIGN_REF (pattern
);
6877 TYPE_HAS_INIT_REF (type
) = TYPE_HAS_INIT_REF (pattern
);
6878 TYPE_HAS_CONST_INIT_REF (type
) = TYPE_HAS_CONST_INIT_REF (pattern
);
6879 TYPE_HAS_DEFAULT_CONSTRUCTOR (type
) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern
);
6880 TYPE_HAS_CONVERSION (type
) = TYPE_HAS_CONVERSION (pattern
);
6881 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
6882 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
6883 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
6884 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
6885 if (ANON_AGGR_TYPE_P (pattern
))
6886 SET_ANON_AGGR_TYPE_P (type
);
6887 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
6889 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
6890 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
6893 pbinfo
= TYPE_BINFO (pattern
);
6895 /* We should never instantiate a nested class before its enclosing
6896 class; we need to look up the nested class by name before we can
6897 instantiate it, and that lookup should instantiate the enclosing
6899 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
6900 || COMPLETE_TYPE_P (TYPE_CONTEXT (type
))
6901 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type
)));
6903 base_list
= NULL_TREE
;
6904 if (BINFO_N_BASE_BINFOS (pbinfo
))
6907 tree context
= TYPE_CONTEXT (type
);
6911 /* We must enter the scope containing the type, as that is where
6912 the accessibility of types named in dependent bases are
6914 pushed_scope
= push_scope (context
? context
: global_namespace
);
6916 /* Substitute into each of the bases to determine the actual
6918 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
6921 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
6922 tree expanded_bases
= NULL_TREE
;
6925 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
6928 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
6929 args
, tf_error
, NULL_TREE
);
6930 if (expanded_bases
== error_mark_node
)
6933 len
= TREE_VEC_LENGTH (expanded_bases
);
6936 for (idx
= 0; idx
< len
; idx
++)
6939 /* Extract the already-expanded base class. */
6940 base
= TREE_VEC_ELT (expanded_bases
, idx
);
6942 /* Substitute to figure out the base class. */
6943 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
6946 if (base
== error_mark_node
)
6949 base_list
= tree_cons (access
, base
, base_list
);
6950 if (BINFO_VIRTUAL_P (pbase_binfo
))
6951 TREE_TYPE (base_list
) = integer_type_node
;
6955 /* The list is now in reverse order; correct that. */
6956 base_list
= nreverse (base_list
);
6959 pop_scope (pushed_scope
);
6961 /* Now call xref_basetypes to set up all the base-class
6963 xref_basetypes (type
, base_list
);
6965 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
6966 (int) ATTR_FLAG_TYPE_IN_PLACE
,
6967 args
, tf_error
, NULL_TREE
);
6969 /* Now that our base classes are set up, enter the scope of the
6970 class, so that name lookups into base classes, etc. will work
6971 correctly. This is precisely analogous to what we do in
6972 begin_class_definition when defining an ordinary non-template
6973 class, except we also need to push the enclosing classes. */
6974 push_nested_class (type
);
6976 /* Now members are processed in the order of declaration. */
6977 for (member
= CLASSTYPE_DECL_LIST (pattern
);
6978 member
; member
= TREE_CHAIN (member
))
6980 tree t
= TREE_VALUE (member
);
6982 if (TREE_PURPOSE (member
))
6986 /* Build new CLASSTYPE_NESTED_UTDS. */
6989 bool class_template_p
;
6991 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
6992 && TYPE_LANG_SPECIFIC (t
)
6993 && CLASSTYPE_IS_TEMPLATE (t
));
6994 /* If the member is a class template, then -- even after
6995 substitution -- there may be dependent types in the
6996 template argument list for the class. We increment
6997 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
6998 that function will assume that no types are dependent
6999 when outside of a template. */
7000 if (class_template_p
)
7001 ++processing_template_decl
;
7002 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
7003 if (class_template_p
)
7004 --processing_template_decl
;
7005 if (newtag
== error_mark_node
)
7008 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
7010 tree name
= TYPE_IDENTIFIER (t
);
7012 if (class_template_p
)
7013 /* Unfortunately, lookup_template_class sets
7014 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7015 instantiation (i.e., for the type of a member
7016 template class nested within a template class.)
7017 This behavior is required for
7018 maybe_process_partial_specialization to work
7019 correctly, but is not accurate in this case;
7020 the TAG is not an instantiation of anything.
7021 (The corresponding TEMPLATE_DECL is an
7022 instantiation, but the TYPE is not.) */
7023 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
7025 /* Now, we call pushtag to put this NEWTAG into the scope of
7026 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7027 pushtag calling push_template_decl. We don't have to do
7028 this for enums because it will already have been done in
7031 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
7032 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
7035 else if (TREE_CODE (t
) == FUNCTION_DECL
7036 || DECL_FUNCTION_TEMPLATE_P (t
))
7038 /* Build new TYPE_METHODS. */
7041 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7042 ++processing_template_decl
;
7043 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
7044 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7045 --processing_template_decl
;
7046 set_current_access_from_decl (r
);
7047 finish_member_declaration (r
);
7051 /* Build new TYPE_FIELDS. */
7052 if (TREE_CODE (t
) == STATIC_ASSERT
)
7055 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
7056 tf_warning_or_error
, NULL_TREE
,
7057 /*integral_constant_expression_p=*/true);
7058 finish_static_assert (condition
,
7059 STATIC_ASSERT_MESSAGE (t
),
7060 STATIC_ASSERT_SOURCE_LOCATION (t
),
7063 else if (TREE_CODE (t
) != CONST_DECL
)
7067 /* The the file and line for this declaration, to
7068 assist in error message reporting. Since we
7069 called push_tinst_level above, we don't need to
7071 input_location
= DECL_SOURCE_LOCATION (t
);
7073 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7074 ++processing_template_decl
;
7075 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
7076 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7077 --processing_template_decl
;
7078 if (TREE_CODE (r
) == VAR_DECL
)
7082 [t]he initialization (and any associated
7083 side-effects) of a static data member does
7084 not occur unless the static data member is
7085 itself used in a way that requires the
7086 definition of the static data member to
7089 Therefore, we do not substitute into the
7090 initialized for the static data member here. */
7091 finish_static_data_member_decl
7094 /*init_const_expr_p=*/false,
7095 /*asmspec_tree=*/NULL_TREE
,
7097 if (DECL_INITIALIZED_IN_CLASS_P (r
))
7098 check_static_variable_definition (r
, TREE_TYPE (r
));
7100 else if (TREE_CODE (r
) == FIELD_DECL
)
7102 /* Determine whether R has a valid type and can be
7103 completed later. If R is invalid, then it is
7104 replaced by error_mark_node so that it will not be
7105 added to TYPE_FIELDS. */
7106 tree rtype
= TREE_TYPE (r
);
7107 if (can_complete_type_without_circularity (rtype
))
7108 complete_type (rtype
);
7110 if (!COMPLETE_TYPE_P (rtype
))
7112 cxx_incomplete_type_error (r
, rtype
);
7113 r
= error_mark_node
;
7117 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7118 such a thing will already have been added to the field
7119 list by tsubst_enum in finish_member_declaration in the
7120 CLASSTYPE_NESTED_UTDS case above. */
7121 if (!(TREE_CODE (r
) == TYPE_DECL
7122 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
7123 && DECL_ARTIFICIAL (r
)))
7125 set_current_access_from_decl (r
);
7126 finish_member_declaration (r
);
7133 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
))
7135 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7137 tree friend_type
= t
;
7138 bool adjust_processing_template_decl
= false;
7140 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
7142 /* template <class T> friend class C; */
7143 friend_type
= tsubst_friend_class (friend_type
, args
);
7144 adjust_processing_template_decl
= true;
7146 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
7148 /* template <class T> friend class C::D; */
7149 friend_type
= tsubst (friend_type
, args
,
7150 tf_warning_or_error
, NULL_TREE
);
7151 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
7152 friend_type
= TREE_TYPE (friend_type
);
7153 adjust_processing_template_decl
= true;
7155 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
)
7157 /* This could be either
7161 when dependent_type_p is false or
7163 template <class U> friend class T::C;
7166 friend_type
= tsubst (friend_type
, args
,
7167 tf_warning_or_error
, NULL_TREE
);
7168 /* Bump processing_template_decl for correct
7169 dependent_type_p calculation. */
7170 ++processing_template_decl
;
7171 if (dependent_type_p (friend_type
))
7172 adjust_processing_template_decl
= true;
7173 --processing_template_decl
;
7175 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
7176 && hidden_name_p (TYPE_NAME (friend_type
)))
7180 where C hasn't been declared yet. Let's lookup name
7181 from namespace scope directly, bypassing any name that
7182 come from dependent base class. */
7183 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
7185 /* The call to xref_tag_from_type does injection for friend
7187 push_nested_namespace (ns
);
7189 xref_tag_from_type (friend_type
, NULL_TREE
,
7190 /*tag_scope=*/ts_current
);
7191 pop_nested_namespace (ns
);
7193 else if (uses_template_parms (friend_type
))
7194 /* friend class C<T>; */
7195 friend_type
= tsubst (friend_type
, args
,
7196 tf_warning_or_error
, NULL_TREE
);
7201 where C is already declared or
7203 friend class C<int>;
7205 We don't have to do anything in these cases. */
7207 if (adjust_processing_template_decl
)
7208 /* Trick make_friend_class into realizing that the friend
7209 we're adding is a template, not an ordinary class. It's
7210 important that we use make_friend_class since it will
7211 perform some error-checking and output cross-reference
7213 ++processing_template_decl
;
7215 if (friend_type
!= error_mark_node
)
7216 make_friend_class (type
, friend_type
, /*complain=*/false);
7218 if (adjust_processing_template_decl
)
7219 --processing_template_decl
;
7223 /* Build new DECL_FRIENDLIST. */
7226 /* The the file and line for this declaration, to
7227 assist in error message reporting. Since we
7228 called push_tinst_level above, we don't need to
7230 input_location
= DECL_SOURCE_LOCATION (t
);
7232 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7234 ++processing_template_decl
;
7235 push_deferring_access_checks (dk_no_check
);
7238 r
= tsubst_friend_function (t
, args
);
7239 add_friend (type
, r
, /*complain=*/false);
7240 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7242 pop_deferring_access_checks ();
7243 --processing_template_decl
;
7249 /* Set the file and line number information to whatever is given for
7250 the class itself. This puts error messages involving generated
7251 implicit functions at a predictable point, and the same point
7252 that would be used for non-template classes. */
7253 input_location
= DECL_SOURCE_LOCATION (typedecl
);
7255 unreverse_member_declarations (type
);
7256 finish_struct_1 (type
);
7257 TYPE_BEING_DEFINED (type
) = 0;
7259 /* Now that the class is complete, instantiate default arguments for
7260 any member functions. We don't do this earlier because the
7261 default arguments may reference members of the class. */
7262 if (!PRIMARY_TEMPLATE_P (template))
7263 for (t
= TYPE_METHODS (type
); t
; t
= TREE_CHAIN (t
))
7264 if (TREE_CODE (t
) == FUNCTION_DECL
7265 /* Implicitly generated member functions will not have template
7266 information; they are not instantiations, but instead are
7267 created "fresh" for each instantiation. */
7268 && DECL_TEMPLATE_INFO (t
))
7269 tsubst_default_arguments (t
);
7271 pop_nested_class ();
7272 pop_from_top_level ();
7273 pop_deferring_access_checks ();
7276 /* The vtable for a template class can be emitted in any translation
7277 unit in which the class is instantiated. When there is no key
7278 method, however, finish_struct_1 will already have added TYPE to
7279 the keyed_classes list. */
7280 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
7281 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
7287 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
7293 else if (TYPE_P (t
))
7294 r
= tsubst (t
, args
, complain
, in_decl
);
7297 r
= tsubst_expr (t
, args
, complain
, in_decl
,
7298 /*integral_constant_expression_p=*/true);
7299 r
= fold_non_dependent_expr (r
);
7304 /* Substitute ARGS into T, which is an pack expansion
7305 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7306 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7307 (if only a partial substitution could be performed) or
7308 ERROR_MARK_NODE if there was an error. */
7310 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
7314 tree pack
, packs
= NULL_TREE
, unsubstituted_packs
= NULL_TREE
;
7315 tree first_arg_pack
; int i
, len
= -1;
7319 gcc_assert (PACK_EXPANSION_P (t
));
7320 pattern
= PACK_EXPANSION_PATTERN (t
);
7322 /* Determine the argument packs that will instantiate the parameter
7323 packs used in the expansion expression. While we're at it,
7324 compute the number of arguments to be expanded and make sure it
7326 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
7327 pack
= TREE_CHAIN (pack
))
7329 tree parm_pack
= TREE_VALUE (pack
);
7330 tree arg_pack
= NULL_TREE
;
7331 tree orig_arg
= NULL_TREE
;
7333 if (TREE_CODE (parm_pack
) == PARM_DECL
)
7334 arg_pack
= retrieve_local_specialization (parm_pack
);
7337 int level
, idx
, levels
;
7338 template_parm_level_and_index (parm_pack
, &level
, &idx
);
7340 levels
= TMPL_ARGS_DEPTH (args
);
7341 if (level
<= levels
)
7342 arg_pack
= TMPL_ARG (args
, level
, idx
);
7345 orig_arg
= arg_pack
;
7346 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
7347 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
7349 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
7350 /* This can only happen if we forget to expand an argument
7351 pack somewhere else. Just return an error, silently. */
7353 result
= make_tree_vec (1);
7354 TREE_VEC_ELT (result
, 0) = error_mark_node
;
7359 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
)) == 1
7360 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack
), 0)))
7362 tree expansion
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack
), 0);
7363 tree pattern
= PACK_EXPANSION_PATTERN (expansion
);
7364 if ((TYPE_P (pattern
) && same_type_p (pattern
, parm_pack
))
7365 || (!TYPE_P (pattern
) && cp_tree_equal (parm_pack
, pattern
)))
7366 /* The argument pack that the parameter maps to is just an
7367 expansion of the parameter itself, such as one would
7368 find in the implicit typedef of a class inside the
7369 class itself. Consider this parameter "unsubstituted",
7370 so that we will maintain the outer pack expansion. */
7371 arg_pack
= NULL_TREE
;
7377 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
7379 /* It's all-or-nothing with incomplete argument packs. */
7380 if (incomplete
&& !ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
7381 return error_mark_node
;
7383 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
7389 first_arg_pack
= arg_pack
;
7391 else if (len
!= my_len
)
7393 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
7394 error ("mismatched argument pack lengths while expanding "
7398 error ("mismatched argument pack lengths while expanding "
7401 return error_mark_node
;
7404 /* Keep track of the parameter packs and their corresponding
7406 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
7407 TREE_TYPE (packs
) = orig_arg
;
7410 /* We can't substitute for this parameter pack. */
7411 unsubstituted_packs
= tree_cons (TREE_PURPOSE (pack
),
7413 unsubstituted_packs
);
7416 /* We cannot expand this expansion expression, because we don't have
7417 all of the argument packs we need. Substitute into the pattern
7418 and return a PACK_EXPANSION_*. The caller will need to deal with
7420 if (unsubstituted_packs
)
7421 return make_pack_expansion (tsubst (pattern
, args
, complain
,
7424 /* We could not find any argument packs that work. */
7426 return error_mark_node
;
7428 /* For each argument in each argument pack, substitute into the
7430 result
= make_tree_vec (len
+ incomplete
);
7431 for (i
= 0; i
< len
+ incomplete
; ++i
)
7433 /* For parameter pack, change the substitution of the parameter
7434 pack to the ith argument in its argument pack, then expand
7436 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
7438 tree parm
= TREE_PURPOSE (pack
);
7440 if (TREE_CODE (parm
) == PARM_DECL
)
7442 /* Select the Ith argument from the pack. */
7443 tree arg
= make_node (ARGUMENT_PACK_SELECT
);
7444 ARGUMENT_PACK_SELECT_FROM_PACK (arg
) = TREE_VALUE (pack
);
7445 ARGUMENT_PACK_SELECT_INDEX (arg
) = i
;
7447 register_local_specialization (arg
, parm
);
7453 template_parm_level_and_index (parm
, &level
, &idx
);
7457 /* Select the Ith argument from the pack. */
7458 value
= make_node (ARGUMENT_PACK_SELECT
);
7459 ARGUMENT_PACK_SELECT_FROM_PACK (value
) = TREE_VALUE (pack
);
7460 ARGUMENT_PACK_SELECT_INDEX (value
) = i
;
7463 /* Update the corresponding argument. */
7464 TMPL_ARG (args
, level
, idx
) = value
;
7468 /* Substitute into the PATTERN with the altered arguments. */
7469 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
7470 TREE_VEC_ELT (result
, i
) =
7471 tsubst_expr (pattern
, args
, complain
, in_decl
,
7472 /*integral_constant_expression_p=*/false);
7474 TREE_VEC_ELT (result
, i
) = tsubst (pattern
, args
, complain
, in_decl
);
7477 /* When we have incomplete argument packs, the last "expanded"
7478 result is itself a pack expansion, which allows us
7479 to deduce more arguments. */
7480 TREE_VEC_ELT (result
, i
) =
7481 make_pack_expansion (TREE_VEC_ELT (result
, i
));
7483 if (TREE_VEC_ELT (result
, i
) == error_mark_node
)
7485 result
= error_mark_node
;
7490 /* Update ARGS to restore the substitution from parameter packs to
7491 their argument packs. */
7492 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
7494 tree parm
= TREE_PURPOSE (pack
);
7496 if (TREE_CODE (parm
) == PARM_DECL
)
7497 register_local_specialization (TREE_TYPE (pack
), parm
);
7501 template_parm_level_and_index (parm
, &level
, &idx
);
7503 /* Update the corresponding argument. */
7504 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
7505 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
7508 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
7515 /* Substitute ARGS into the vector or list of template arguments T. */
7518 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
7521 int len
= TREE_VEC_LENGTH (t
);
7522 int need_new
= 0, i
, expanded_len_adjust
= 0, out
;
7523 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
7525 for (i
= 0; i
< len
; i
++)
7527 tree orig_arg
= TREE_VEC_ELT (t
, i
);
7530 if (TREE_CODE (orig_arg
) == TREE_VEC
)
7531 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
7532 else if (PACK_EXPANSION_P (orig_arg
))
7534 /* Substitute into an expansion expression. */
7535 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
7537 if (TREE_CODE (new_arg
) == TREE_VEC
)
7538 /* Add to the expanded length adjustment the number of
7539 expanded arguments. We subtract one from this
7540 measurement, because the argument pack expression
7541 itself is already counted as 1 in
7542 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7543 the argument pack is empty. */
7544 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
7546 else if (ARGUMENT_PACK_P (orig_arg
))
7548 /* Substitute into each of the arguments. */
7549 new_arg
= make_node (TREE_CODE (orig_arg
));
7551 SET_ARGUMENT_PACK_ARGS (
7553 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
7554 args
, complain
, in_decl
));
7556 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
7557 new_arg
= error_mark_node
;
7559 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
7560 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
7562 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
7564 if (TREE_TYPE (new_arg
) == error_mark_node
)
7565 new_arg
= error_mark_node
;
7569 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
7571 if (new_arg
== error_mark_node
)
7572 return error_mark_node
;
7575 if (new_arg
!= orig_arg
)
7582 /* Make space for the expanded arguments coming from template
7584 t
= make_tree_vec (len
+ expanded_len_adjust
);
7585 for (i
= 0, out
= 0; i
< len
; i
++)
7587 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
7588 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
7589 && TREE_CODE (elts
[i
]) == TREE_VEC
)
7593 /* Now expand the template argument pack "in place". */
7594 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
7595 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
7599 TREE_VEC_ELT (t
, out
) = elts
[i
];
7607 /* Return the result of substituting ARGS into the template parameters
7608 given by PARMS. If there are m levels of ARGS and m + n levels of
7609 PARMS, then the result will contain n levels of PARMS. For
7610 example, if PARMS is `template <class T> template <class U>
7611 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7612 result will be `template <int*, double, class V>'. */
7615 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
7620 /* When substituting into a template, we must set
7621 PROCESSING_TEMPLATE_DECL as the template parameters may be
7622 dependent if they are based on one-another, and the dependency
7623 predicates are short-circuit outside of templates. */
7624 ++processing_template_decl
;
7626 for (new_parms
= &r
;
7627 TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
7628 new_parms
= &(TREE_CHAIN (*new_parms
)),
7629 parms
= TREE_CHAIN (parms
))
7632 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
7635 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
7641 if (parms
== error_mark_node
)
7644 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
7646 if (tuple
== error_mark_node
)
7649 default_value
= TREE_PURPOSE (tuple
);
7650 parm_decl
= TREE_VALUE (tuple
);
7652 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
7653 if (TREE_CODE (parm_decl
) == PARM_DECL
7654 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
7655 parm_decl
= error_mark_node
;
7656 default_value
= tsubst_template_arg (default_value
, args
,
7657 complain
, NULL_TREE
);
7659 tuple
= build_tree_list (default_value
, parm_decl
);
7660 TREE_VEC_ELT (new_vec
, i
) = tuple
;
7664 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
7665 - TMPL_ARGS_DEPTH (args
)),
7666 new_vec
, NULL_TREE
);
7669 --processing_template_decl
;
7674 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7675 type T. If T is not an aggregate or enumeration type, it is
7676 handled as if by tsubst. IN_DECL is as for tsubst. If
7677 ENTERING_SCOPE is nonzero, T is the context for a template which
7678 we are presently tsubst'ing. Return the substituted value. */
7681 tsubst_aggr_type (tree t
,
7683 tsubst_flags_t complain
,
7690 switch (TREE_CODE (t
))
7693 if (TYPE_PTRMEMFUNC_P (t
))
7694 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
7696 /* Else fall through. */
7699 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
7704 bool saved_skip_evaluation
;
7706 /* In "sizeof(X<I>)" we need to evaluate "I". */
7707 saved_skip_evaluation
= skip_evaluation
;
7708 skip_evaluation
= false;
7710 /* First, determine the context for the type we are looking
7712 context
= TYPE_CONTEXT (t
);
7715 context
= tsubst_aggr_type (context
, args
, complain
,
7716 in_decl
, /*entering_scope=*/1);
7717 /* If context is a nested class inside a class template,
7718 it may still need to be instantiated (c++/33959). */
7719 if (TYPE_P (context
))
7720 context
= complete_type (context
);
7723 /* Then, figure out what arguments are appropriate for the
7724 type we are trying to find. For example, given:
7726 template <class T> struct S;
7727 template <class T, class U> void f(T, U) { S<U> su; }
7729 and supposing that we are instantiating f<int, double>,
7730 then our ARGS will be {int, double}, but, when looking up
7731 S we only want {double}. */
7732 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
7734 if (argvec
== error_mark_node
)
7735 r
= error_mark_node
;
7738 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
7739 entering_scope
, complain
);
7740 r
= cp_build_qualified_type_real (r
, TYPE_QUALS (t
), complain
);
7743 skip_evaluation
= saved_skip_evaluation
;
7748 /* This is not a template type, so there's nothing to do. */
7752 return tsubst (t
, args
, complain
, in_decl
);
7756 /* Substitute into the default argument ARG (a default argument for
7757 FN), which has the indicated TYPE. */
7760 tsubst_default_argument (tree fn
, tree type
, tree arg
)
7762 tree saved_class_ptr
= NULL_TREE
;
7763 tree saved_class_ref
= NULL_TREE
;
7765 /* This default argument came from a template. Instantiate the
7766 default argument here, not in tsubst. In the case of
7775 we must be careful to do name lookup in the scope of S<T>,
7776 rather than in the current class. */
7777 push_access_scope (fn
);
7778 /* The "this" pointer is not valid in a default argument. */
7781 saved_class_ptr
= current_class_ptr
;
7782 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
7783 saved_class_ref
= current_class_ref
;
7784 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
7787 push_deferring_access_checks(dk_no_deferred
);
7788 /* The default argument expression may cause implicitly defined
7789 member functions to be synthesized, which will result in garbage
7790 collection. We must treat this situation as if we were within
7791 the body of function so as to avoid collecting live data on the
7794 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
7795 tf_warning_or_error
, NULL_TREE
,
7796 /*integral_constant_expression_p=*/false);
7798 pop_deferring_access_checks();
7800 /* Restore the "this" pointer. */
7803 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
7804 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
7807 pop_access_scope (fn
);
7809 /* Make sure the default argument is reasonable. */
7810 arg
= check_default_argument (type
, arg
);
7815 /* Substitute into all the default arguments for FN. */
7818 tsubst_default_arguments (tree fn
)
7823 tmpl_args
= DECL_TI_ARGS (fn
);
7825 /* If this function is not yet instantiated, we certainly don't need
7826 its default arguments. */
7827 if (uses_template_parms (tmpl_args
))
7830 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7832 arg
= TREE_CHAIN (arg
))
7833 if (TREE_PURPOSE (arg
))
7834 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
7836 TREE_PURPOSE (arg
));
7839 /* Substitute the ARGS into the T, which is a _DECL. Return the
7840 result of the substitution. Issue error and warning messages under
7841 control of COMPLAIN. */
7844 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
7846 location_t saved_loc
;
7850 /* Set the filename and linenumber to improve error-reporting. */
7851 saved_loc
= input_location
;
7852 input_location
= DECL_SOURCE_LOCATION (t
);
7854 switch (TREE_CODE (t
))
7858 /* We can get here when processing a member function template,
7859 member class template, and template template parameter of
7860 a template class. */
7861 tree decl
= DECL_TEMPLATE_RESULT (t
);
7866 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
7868 /* Template template parameter is treated here. */
7869 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7870 if (new_type
== error_mark_node
)
7871 return error_mark_node
;
7874 TREE_CHAIN (r
) = NULL_TREE
;
7875 TREE_TYPE (r
) = new_type
;
7876 DECL_TEMPLATE_RESULT (r
)
7877 = build_decl (TYPE_DECL
, DECL_NAME (decl
), new_type
);
7878 DECL_TEMPLATE_PARMS (r
)
7879 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
7881 TYPE_NAME (new_type
) = r
;
7885 /* We might already have an instance of this template.
7886 The ARGS are for the surrounding class type, so the
7887 full args contain the tsubst'd args for the context,
7888 plus the innermost args from the template decl. */
7889 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
7890 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
7891 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
7892 /* Because this is a template, the arguments will still be
7893 dependent, even after substitution. If
7894 PROCESSING_TEMPLATE_DECL is not set, the dependency
7895 predicates will short-circuit. */
7896 ++processing_template_decl
;
7897 full_args
= tsubst_template_args (tmpl_args
, args
,
7899 --processing_template_decl
;
7900 if (full_args
== error_mark_node
)
7901 return error_mark_node
;
7903 /* tsubst_template_args doesn't copy the vector if
7904 nothing changed. But, *something* should have
7906 gcc_assert (full_args
!= tmpl_args
);
7908 spec
= retrieve_specialization (t
, full_args
,
7909 /*class_specializations_p=*/true);
7910 if (spec
!= NULL_TREE
)
7916 /* Make a new template decl. It will be similar to the
7917 original, but will record the current template arguments.
7918 We also create a new function declaration, which is just
7919 like the old one, but points to this new template, rather
7920 than the old one. */
7922 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
7923 TREE_CHAIN (r
) = NULL_TREE
;
7925 DECL_TEMPLATE_INFO (r
) = build_tree_list (t
, args
);
7927 if (TREE_CODE (decl
) == TYPE_DECL
)
7930 ++processing_template_decl
;
7931 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7932 --processing_template_decl
;
7933 if (new_type
== error_mark_node
)
7934 return error_mark_node
;
7936 TREE_TYPE (r
) = new_type
;
7937 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
7938 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
7939 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
7940 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
7945 ++processing_template_decl
;
7946 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
7947 --processing_template_decl
;
7948 if (new_decl
== error_mark_node
)
7949 return error_mark_node
;
7951 DECL_TEMPLATE_RESULT (r
) = new_decl
;
7952 DECL_TI_TEMPLATE (new_decl
) = r
;
7953 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
7954 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
7955 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
7958 SET_DECL_IMPLICIT_INSTANTIATION (r
);
7959 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
7960 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
7962 /* The template parameters for this new template are all the
7963 template parameters for the old template, except the
7964 outermost level of parameters. */
7965 DECL_TEMPLATE_PARMS (r
)
7966 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
7969 if (PRIMARY_TEMPLATE_P (t
))
7970 DECL_PRIMARY_TEMPLATE (r
) = r
;
7972 if (TREE_CODE (decl
) != TYPE_DECL
)
7973 /* Record this non-type partial instantiation. */
7974 register_specialization (r
, t
,
7975 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
7983 tree argvec
= NULL_TREE
;
7991 /* Nobody should be tsubst'ing into non-template functions. */
7992 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
7994 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
7999 /* If T is not dependent, just return it. We have to
8000 increment PROCESSING_TEMPLATE_DECL because
8001 value_dependent_expression_p assumes that nothing is
8002 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8003 ++processing_template_decl
;
8004 dependent_p
= value_dependent_expression_p (t
);
8005 --processing_template_decl
;
8009 /* Calculate the most general template of which R is a
8010 specialization, and the complete set of arguments used to
8012 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
8013 argvec
= tsubst_template_args (DECL_TI_ARGS
8014 (DECL_TEMPLATE_RESULT (gen_tmpl
)),
8015 args
, complain
, in_decl
);
8017 /* Check to see if we already have this specialization. */
8018 spec
= retrieve_specialization (gen_tmpl
, argvec
,
8019 /*class_specializations_p=*/false);
8027 /* We can see more levels of arguments than parameters if
8028 there was a specialization of a member template, like
8031 template <class T> struct S { template <class U> void f(); }
8032 template <> template <class U> void S<int>::f(U);
8034 Here, we'll be substituting into the specialization,
8035 because that's where we can find the code we actually
8036 want to generate, but we'll have enough arguments for
8037 the most general template.
8039 We also deal with the peculiar case:
8041 template <class T> struct S {
8042 template <class U> friend void f();
8044 template <class U> void f() {}
8046 template void f<double>();
8048 Here, the ARGS for the instantiation of will be {int,
8049 double}. But, we only need as many ARGS as there are
8050 levels of template parameters in CODE_PATTERN. We are
8051 careful not to get fooled into reducing the ARGS in
8054 template <class T> struct S { template <class U> void f(U); }
8055 template <class T> template <> void S<T>::f(int) {}
8057 which we can spot because the pattern will be a
8058 specialization in this case. */
8059 args_depth
= TMPL_ARGS_DEPTH (args
);
8061 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
8062 if (args_depth
> parms_depth
8063 && !DECL_TEMPLATE_SPECIALIZATION (t
))
8064 args
= get_innermost_template_args (args
, parms_depth
);
8068 /* This special case arises when we have something like this:
8070 template <class T> struct S {
8071 friend void f<int>(int, double);
8074 Here, the DECL_TI_TEMPLATE for the friend declaration
8075 will be an IDENTIFIER_NODE. We are being called from
8076 tsubst_friend_function, and we want only to create a
8077 new decl (R) with appropriate types so that we can call
8078 determine_specialization. */
8079 gen_tmpl
= NULL_TREE
;
8082 if (DECL_CLASS_SCOPE_P (t
))
8084 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
8088 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
8089 complain
, t
, /*entering_scope=*/1);
8094 ctx
= DECL_CONTEXT (t
);
8096 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8097 if (type
== error_mark_node
)
8098 return error_mark_node
;
8100 /* We do NOT check for matching decls pushed separately at this
8101 point, as they may not represent instantiations of this
8102 template, and in any case are considered separate under the
8105 DECL_USE_TEMPLATE (r
) = 0;
8106 TREE_TYPE (r
) = type
;
8107 /* Clear out the mangled name and RTL for the instantiation. */
8108 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
8109 SET_DECL_RTL (r
, NULL_RTX
);
8110 DECL_INITIAL (r
) = NULL_TREE
;
8111 DECL_CONTEXT (r
) = ctx
;
8113 if (member
&& DECL_CONV_FN_P (r
))
8114 /* Type-conversion operator. Reconstruct the name, in
8115 case it's the name of one of the template's parameters. */
8116 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
8118 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
8120 DECL_RESULT (r
) = NULL_TREE
;
8122 TREE_STATIC (r
) = 0;
8123 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
8124 DECL_EXTERNAL (r
) = 1;
8125 /* If this is an instantiation of a function with internal
8126 linkage, we already know what object file linkage will be
8127 assigned to the instantiation. */
8128 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
8129 DECL_DEFER_OUTPUT (r
) = 0;
8130 TREE_CHAIN (r
) = NULL_TREE
;
8131 DECL_PENDING_INLINE_INFO (r
) = 0;
8132 DECL_PENDING_INLINE_P (r
) = 0;
8133 DECL_SAVED_TREE (r
) = NULL_TREE
;
8135 if (DECL_CLONED_FUNCTION (r
))
8137 DECL_CLONED_FUNCTION (r
) = tsubst (DECL_CLONED_FUNCTION (t
),
8139 TREE_CHAIN (r
) = TREE_CHAIN (DECL_CLONED_FUNCTION (r
));
8140 TREE_CHAIN (DECL_CLONED_FUNCTION (r
)) = r
;
8143 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8144 this in the special friend case mentioned above where
8145 GEN_TMPL is NULL. */
8148 DECL_TEMPLATE_INFO (r
)
8149 = tree_cons (gen_tmpl
, argvec
, NULL_TREE
);
8150 SET_DECL_IMPLICIT_INSTANTIATION (r
);
8151 register_specialization (r
, gen_tmpl
, argvec
, false);
8153 /* We're not supposed to instantiate default arguments
8154 until they are called, for a template. But, for a
8157 template <class T> void f ()
8158 { extern void g(int i = T()); }
8160 we should do the substitution when the template is
8161 instantiated. We handle the member function case in
8162 instantiate_class_template since the default arguments
8163 might refer to other members of the class. */
8165 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
8166 && !uses_template_parms (argvec
))
8167 tsubst_default_arguments (r
);
8170 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
8172 /* Copy the list of befriending classes. */
8173 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
8175 friends
= &TREE_CHAIN (*friends
))
8177 *friends
= copy_node (*friends
);
8178 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
8183 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
8185 maybe_retrofit_in_chrg (r
);
8186 if (DECL_CONSTRUCTOR_P (r
))
8187 grok_ctor_properties (ctx
, r
);
8188 /* If this is an instantiation of a member template, clone it.
8189 If it isn't, that'll be handled by
8190 clone_constructors_and_destructors. */
8191 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
8192 clone_function_decl (r
, /*update_method_vec_p=*/0);
8194 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r
))
8195 && !grok_op_properties (r
, (complain
& tf_error
) != 0))
8196 return error_mark_node
;
8198 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
8199 SET_DECL_FRIEND_CONTEXT (r
,
8200 tsubst (DECL_FRIEND_CONTEXT (t
),
8201 args
, complain
, in_decl
));
8203 /* Possibly limit visibility based on template args. */
8204 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
8205 if (DECL_VISIBILITY_SPECIFIED (t
))
8207 DECL_VISIBILITY_SPECIFIED (r
) = 0;
8209 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
8211 determine_visibility (r
);
8213 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
8214 args
, complain
, in_decl
);
8220 tree type
= NULL_TREE
;
8222 tree expanded_types
= NULL_TREE
;
8223 tree prev_r
= NULL_TREE
;
8224 tree first_r
= NULL_TREE
;
8226 if (FUNCTION_PARAMETER_PACK_P (t
))
8228 /* If there is a local specialization that isn't a
8229 parameter pack, it means that we're doing a "simple"
8230 substitution from inside tsubst_pack_expansion. Just
8231 return the local specialization (which will be a single
8233 tree spec
= retrieve_local_specialization (t
);
8235 && TREE_CODE (spec
) == PARM_DECL
8236 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
8239 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8240 the parameters in this function parameter pack. */
8241 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
8243 if (TREE_CODE (expanded_types
) == TREE_VEC
)
8245 len
= TREE_VEC_LENGTH (expanded_types
);
8247 /* Zero-length parameter packs are boring. Just substitute
8250 return tsubst (TREE_CHAIN (t
), args
, complain
,
8255 /* All we did was update the type. Make a note of that. */
8256 type
= expanded_types
;
8257 expanded_types
= NULL_TREE
;
8261 /* Loop through all of the parameter's we'll build. When T is
8262 a function parameter pack, LEN is the number of expanded
8263 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8265 for (i
= 0; i
< len
; ++i
)
8269 if (DECL_TEMPLATE_PARM_P (t
))
8270 SET_DECL_TEMPLATE_PARM_P (r
);
8273 /* We're on the Ith parameter of the function parameter
8276 /* Get the Ith type. */
8277 type
= TREE_VEC_ELT (expanded_types
, i
);
8280 /* Rename the parameter to include the index. */
8282 make_ith_pack_parameter_name (DECL_NAME (r
), i
);
8285 /* We're dealing with a normal parameter. */
8286 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8288 type
= type_decays_to (type
);
8289 TREE_TYPE (r
) = type
;
8290 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
8292 if (DECL_INITIAL (r
))
8294 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
8295 DECL_INITIAL (r
) = TREE_TYPE (r
);
8297 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
8301 DECL_CONTEXT (r
) = NULL_TREE
;
8303 if (!DECL_TEMPLATE_PARM_P (r
))
8304 DECL_ARG_TYPE (r
) = type_passed_as (type
);
8306 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
8307 args
, complain
, in_decl
);
8309 /* Keep track of the first new parameter we
8310 generate. That's what will be returned to the
8315 /* Build a proper chain of parameters when substituting
8316 into a function parameter pack. */
8318 TREE_CHAIN (prev_r
) = r
;
8322 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
,
8323 complain
, TREE_CHAIN (t
));
8325 /* FIRST_R contains the start of the chain we've built. */
8335 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8336 if (type
== error_mark_node
)
8337 return error_mark_node
;
8338 TREE_TYPE (r
) = type
;
8339 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
8341 /* DECL_INITIAL gives the number of bits in a bit-field. */
8343 = tsubst_expr (DECL_INITIAL (t
), args
,
8345 /*integral_constant_expression_p=*/true);
8346 /* We don't have to set DECL_CONTEXT here; it is set by
8347 finish_member_declaration. */
8348 TREE_CHAIN (r
) = NULL_TREE
;
8349 if (VOID_TYPE_P (type
))
8350 error ("instantiation of %q+D as type %qT", r
, type
);
8352 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
8353 args
, complain
, in_decl
);
8358 /* We reach here only for member using decls. */
8359 if (DECL_DEPENDENT_P (t
))
8361 r
= do_class_using_decl
8362 (tsubst_copy (USING_DECL_SCOPE (t
), args
, complain
, in_decl
),
8363 tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
));
8365 r
= error_mark_node
;
8370 TREE_CHAIN (r
) = NULL_TREE
;
8377 tree argvec
= NULL_TREE
;
8378 tree gen_tmpl
= NULL_TREE
;
8380 tree tmpl
= NULL_TREE
;
8382 tree type
= NULL_TREE
;
8385 if (TREE_CODE (t
) == TYPE_DECL
8386 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
8388 /* If this is the canonical decl, we don't have to
8389 mess with instantiations, and often we can't (for
8390 typename, template type parms and such). Note that
8391 TYPE_NAME is not correct for the above test if
8392 we've copied the type for a typedef. */
8393 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8394 if (type
== error_mark_node
)
8395 return error_mark_node
;
8396 r
= TYPE_NAME (type
);
8400 /* Check to see if we already have the specialization we
8403 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
8405 /* T is a static data member or namespace-scope entity.
8406 We have to substitute into namespace-scope variables
8407 (even though such entities are never templates) because
8410 template <class T> void f() { extern T t; }
8412 where the entity referenced is not known until
8413 instantiation time. */
8415 ctx
= DECL_CONTEXT (t
);
8416 if (DECL_CLASS_SCOPE_P (t
))
8418 ctx
= tsubst_aggr_type (ctx
, args
,
8420 in_decl
, /*entering_scope=*/1);
8421 /* If CTX is unchanged, then T is in fact the
8422 specialization we want. That situation occurs when
8423 referencing a static data member within in its own
8424 class. We can use pointer equality, rather than
8425 same_type_p, because DECL_CONTEXT is always
8427 if (ctx
== DECL_CONTEXT (t
))
8433 tmpl
= DECL_TI_TEMPLATE (t
);
8434 gen_tmpl
= most_general_template (tmpl
);
8435 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
8436 spec
= (retrieve_specialization
8438 /*class_specializations_p=*/false));
8443 /* A local variable. */
8445 /* Subsequent calls to pushdecl will fill this in. */
8447 spec
= retrieve_local_specialization (t
);
8449 /* If we already have the specialization we need, there is
8450 nothing more to do. */
8457 /* Create a new node for the specialization we need. */
8459 if (type
== NULL_TREE
)
8460 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8461 if (TREE_CODE (r
) == VAR_DECL
)
8463 /* Even if the original location is out of scope, the
8464 newly substituted one is not. */
8465 DECL_DEAD_FOR_LOCAL (r
) = 0;
8466 DECL_INITIALIZED_P (r
) = 0;
8467 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
8468 if (type
== error_mark_node
)
8469 return error_mark_node
;
8470 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8472 /* It may seem that this case cannot occur, since:
8477 declares a function, not a variable. However:
8480 template <typename T> void g() { T t; }
8481 template void g<f>();
8483 is an attempt to declare a variable with function
8485 error ("variable %qD has function type",
8486 /* R is not yet sufficiently initialized, so we
8487 just use its name. */
8489 return error_mark_node
;
8491 type
= complete_type (type
);
8492 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
8493 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
);
8494 type
= check_var_type (DECL_NAME (r
), type
);
8496 if (DECL_HAS_VALUE_EXPR_P (t
))
8498 tree ve
= DECL_VALUE_EXPR (t
);
8499 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
8500 /*constant_expression_p=*/false);
8501 SET_DECL_VALUE_EXPR (r
, ve
);
8504 else if (DECL_SELF_REFERENCE_P (t
))
8505 SET_DECL_SELF_REFERENCE_P (r
);
8506 TREE_TYPE (r
) = type
;
8507 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
8508 DECL_CONTEXT (r
) = ctx
;
8509 /* Clear out the mangled name and RTL for the instantiation. */
8510 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
8511 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
8512 SET_DECL_RTL (r
, NULL_RTX
);
8513 /* The initializer must not be expanded until it is required;
8515 DECL_INITIAL (r
) = NULL_TREE
;
8516 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
8517 SET_DECL_RTL (r
, NULL_RTX
);
8518 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
8519 if (TREE_CODE (r
) == VAR_DECL
)
8521 /* Possibly limit visibility based on template args. */
8522 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
8523 if (DECL_VISIBILITY_SPECIFIED (t
))
8525 DECL_VISIBILITY_SPECIFIED (r
) = 0;
8527 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
8529 determine_visibility (r
);
8531 /* Preserve a typedef that names a type. */
8532 else if (TREE_CODE (r
) == TYPE_DECL
8533 && DECL_ORIGINAL_TYPE (t
)
8534 && type
!= error_mark_node
)
8536 DECL_ORIGINAL_TYPE (r
) = tsubst (DECL_ORIGINAL_TYPE (t
),
8537 args
, complain
, in_decl
);
8538 TREE_TYPE (r
) = type
= build_variant_type_copy (type
);
8539 TYPE_NAME (type
) = r
;
8544 /* A static data member declaration is always marked
8545 external when it is declared in-class, even if an
8546 initializer is present. We mimic the non-template
8548 DECL_EXTERNAL (r
) = 1;
8550 register_specialization (r
, gen_tmpl
, argvec
, false);
8551 DECL_TEMPLATE_INFO (r
) = tree_cons (tmpl
, argvec
, NULL_TREE
);
8552 SET_DECL_IMPLICIT_INSTANTIATION (r
);
8555 register_local_specialization (r
, t
);
8557 TREE_CHAIN (r
) = NULL_TREE
;
8559 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
8560 (int) ATTR_FLAG_TYPE_IN_PLACE
,
8561 args
, complain
, in_decl
);
8570 /* Restore the file and line information. */
8571 input_location
= saved_loc
;
8576 /* Substitute into the ARG_TYPES of a function type. */
8579 tsubst_arg_types (tree arg_types
,
8581 tsubst_flags_t complain
,
8584 tree remaining_arg_types
;
8585 tree type
= NULL_TREE
;
8587 tree expanded_args
= NULL_TREE
;
8590 if (!arg_types
|| arg_types
== void_list_node
)
8593 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
8594 args
, complain
, in_decl
);
8595 if (remaining_arg_types
== error_mark_node
)
8596 return error_mark_node
;
8598 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
8600 /* For a pack expansion, perform substitution on the
8601 entire expression. Later on, we'll handle the arguments
8603 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
8604 args
, complain
, in_decl
);
8606 if (TREE_CODE (expanded_args
) == TREE_VEC
)
8607 /* So that we'll spin through the parameters, one by one. */
8608 i
= TREE_VEC_LENGTH (expanded_args
);
8611 /* We only partially substituted into the parameter
8612 pack. Our type is TYPE_PACK_EXPANSION. */
8613 type
= expanded_args
;
8614 expanded_args
= NULL_TREE
;
8622 type
= TREE_VEC_ELT (expanded_args
, i
);
8624 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
8626 if (type
== error_mark_node
)
8627 return error_mark_node
;
8628 if (VOID_TYPE_P (type
))
8630 if (complain
& tf_error
)
8632 error ("invalid parameter type %qT", type
);
8634 error ("in declaration %q+D", in_decl
);
8636 return error_mark_node
;
8639 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8640 top-level qualifiers as required. */
8641 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
8643 /* We do not substitute into default arguments here. The standard
8644 mandates that they be instantiated only when needed, which is
8645 done in build_over_call. */
8646 default_arg
= TREE_PURPOSE (arg_types
);
8648 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
8650 /* We've instantiated a template before its default arguments
8651 have been parsed. This can happen for a nested template
8652 class, and is not an error unless we require the default
8653 argument in a call of this function. */
8654 remaining_arg_types
=
8655 tree_cons (default_arg
, type
, remaining_arg_types
);
8656 VEC_safe_push (tree
, gc
, DEFARG_INSTANTIATIONS (default_arg
),
8657 remaining_arg_types
);
8660 remaining_arg_types
=
8661 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
8664 return remaining_arg_types
;
8667 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8668 *not* handle the exception-specification for FNTYPE, because the
8669 initial substitution of explicitly provided template parameters
8670 during argument deduction forbids substitution into the
8671 exception-specification:
8675 All references in the function type of the function template to the
8676 corresponding template parameters are replaced by the specified tem-
8677 plate argument values. If a substitution in a template parameter or
8678 in the function type of the function template results in an invalid
8679 type, type deduction fails. [Note: The equivalent substitution in
8680 exception specifications is done only when the function is instanti-
8681 ated, at which point a program is ill-formed if the substitution
8682 results in an invalid type.] */
8685 tsubst_function_type (tree t
,
8687 tsubst_flags_t complain
,
8694 /* The TYPE_CONTEXT is not used for function/method types. */
8695 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
8697 /* Substitute the return type. */
8698 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8699 if (return_type
== error_mark_node
)
8700 return error_mark_node
;
8701 /* The standard does not presently indicate that creation of a
8702 function type with an invalid return type is a deduction failure.
8703 However, that is clearly analogous to creating an array of "void"
8704 or a reference to a reference. This is core issue #486. */
8705 if (TREE_CODE (return_type
) == ARRAY_TYPE
8706 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
8708 if (complain
& tf_error
)
8710 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
8711 error ("function returning an array");
8713 error ("function returning a function");
8715 return error_mark_node
;
8718 /* Substitute the argument types. */
8719 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
,
8721 if (arg_types
== error_mark_node
)
8722 return error_mark_node
;
8724 if (TYPE_QUALS (return_type
) != TYPE_UNQUALIFIED
8725 && in_decl
!= NULL_TREE
8726 && !TREE_NO_WARNING (in_decl
)
8727 && (SCALAR_TYPE_P (return_type
) || VOID_TYPE_P (return_type
)))
8728 warning (OPT_Wignored_qualifiers
,
8729 "type qualifiers ignored on function return type");
8731 /* Construct a new type node and return it. */
8732 if (TREE_CODE (t
) == FUNCTION_TYPE
)
8733 fntype
= build_function_type (return_type
, arg_types
);
8736 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
8737 if (! IS_AGGR_TYPE (r
))
8741 Type deduction may fail for any of the following
8744 -- Attempting to create "pointer to member of T" when T
8745 is not a class type. */
8746 if (complain
& tf_error
)
8747 error ("creating pointer to member function of non-class type %qT",
8749 return error_mark_node
;
8752 fntype
= build_method_type_directly (r
, return_type
,
8753 TREE_CHAIN (arg_types
));
8755 fntype
= cp_build_qualified_type_real (fntype
, TYPE_QUALS (t
), complain
);
8756 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
8761 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8762 ARGS into that specification, and return the substituted
8763 specification. If there is no specification, return NULL_TREE. */
8766 tsubst_exception_specification (tree fntype
,
8768 tsubst_flags_t complain
,
8774 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
8775 new_specs
= NULL_TREE
;
8778 if (! TREE_VALUE (specs
))
8785 tree expanded_specs
= NULL_TREE
;
8787 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
8789 /* Expand the pack expansion type. */
8790 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
8794 if (expanded_specs
== error_mark_node
)
8795 return error_mark_node
;
8796 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
8797 len
= TREE_VEC_LENGTH (expanded_specs
);
8800 /* We're substituting into a member template, so
8801 we got a TYPE_PACK_EXPANSION back. Add that
8802 expansion and move on. */
8803 gcc_assert (TREE_CODE (expanded_specs
)
8804 == TYPE_PACK_EXPANSION
);
8805 new_specs
= add_exception_specifier (new_specs
,
8808 specs
= TREE_CHAIN (specs
);
8813 for (i
= 0; i
< len
; ++i
)
8816 spec
= TREE_VEC_ELT (expanded_specs
, i
);
8818 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
8819 if (spec
== error_mark_node
)
8821 new_specs
= add_exception_specifier (new_specs
, spec
,
8825 specs
= TREE_CHAIN (specs
);
8831 /* Take the tree structure T and replace template parameters used
8832 therein with the argument vector ARGS. IN_DECL is an associated
8833 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8834 Issue error and warning messages under control of COMPLAIN. Note
8835 that we must be relatively non-tolerant of extensions here, in
8836 order to preserve conformance; if we allow substitutions that
8837 should not be allowed, we may allow argument deductions that should
8838 not succeed, and therefore report ambiguous overload situations
8839 where there are none. In theory, we could allow the substitution,
8840 but indicate that it should have failed, and allow our caller to
8841 make sure that the right thing happens, but we don't try to do this
8844 This function is used for dealing with types, decls and the like;
8845 for expressions, use tsubst_expr or tsubst_copy. */
8848 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
8852 if (t
== NULL_TREE
|| t
== error_mark_node
8853 || t
== integer_type_node
8854 || t
== void_type_node
8855 || t
== char_type_node
8856 || t
== unknown_type_node
8857 || TREE_CODE (t
) == NAMESPACE_DECL
)
8861 return tsubst_decl (t
, args
, complain
);
8863 if (args
== NULL_TREE
)
8866 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
8867 type
= IDENTIFIER_TYPE_VALUE (t
);
8869 type
= TREE_TYPE (t
);
8871 gcc_assert (type
!= unknown_type_node
);
8873 /* Reuse typedefs. We need to do this to handle dependent attributes,
8874 such as attribute aligned. */
8877 && TYPE_NAME (t
) != TYPE_MAIN_DECL (t
))
8879 tree decl
= TYPE_NAME (t
);
8881 if (DECL_CLASS_SCOPE_P (decl
)
8882 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
8883 && uses_template_parms (DECL_CONTEXT (decl
)))
8885 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
8886 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
8887 r
= retrieve_specialization (tmpl
, gen_args
, false);
8889 else if (DECL_FUNCTION_SCOPE_P (decl
)
8890 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
8891 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
8892 r
= retrieve_local_specialization (decl
);
8894 /* The typedef is from a non-template context. */
8900 r
= cp_build_qualified_type_real
8901 (r
, cp_type_quals (t
) | cp_type_quals (r
),
8902 complain
| tf_ignore_bad_quals
);
8905 /* Else we must be instantiating the typedef, so fall through. */
8909 && TREE_CODE (t
) != TYPENAME_TYPE
8910 && TREE_CODE (t
) != IDENTIFIER_NODE
8911 && TREE_CODE (t
) != FUNCTION_TYPE
8912 && TREE_CODE (t
) != METHOD_TYPE
)
8913 type
= tsubst (type
, args
, complain
, in_decl
);
8914 if (type
== error_mark_node
)
8915 return error_mark_node
;
8917 switch (TREE_CODE (t
))
8922 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
8923 /*entering_scope=*/0);
8926 case IDENTIFIER_NODE
:
8938 if (t
== integer_type_node
)
8941 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
8942 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
8946 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
8948 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
8949 /*integral_constant_expression_p=*/false);
8950 max
= fold_decl_constant_value (max
);
8952 if (TREE_CODE (max
) != INTEGER_CST
8953 && !at_function_scope_p ()
8954 && !value_dependent_expression_p (max
))
8956 if (complain
& tf_error
)
8957 error ("array bound is not an integer constant");
8958 return error_mark_node
;
8963 Type deduction may fail for any of the following
8966 Attempting to create an array with a size that is
8967 zero or negative. */
8968 if (integer_zerop (max
) && !(complain
& tf_error
))
8969 /* We must fail if performing argument deduction (as
8970 indicated by the state of complain), so that
8971 another substitution can be found. */
8972 return error_mark_node
;
8973 else if (TREE_CODE (max
) == INTEGER_CST
8974 && INT_CST_LT (max
, integer_zero_node
))
8976 if (complain
& tf_error
)
8977 error ("creating array with negative size (%qE)", max
);
8979 return error_mark_node
;
8982 return compute_array_index_type (NULL_TREE
, max
);
8985 case TEMPLATE_TYPE_PARM
:
8986 case TEMPLATE_TEMPLATE_PARM
:
8987 case BOUND_TEMPLATE_TEMPLATE_PARM
:
8988 case TEMPLATE_PARM_INDEX
:
8993 tree arg
= NULL_TREE
;
8997 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
8998 template_parm_level_and_index (t
, &level
, &idx
);
9000 levels
= TMPL_ARGS_DEPTH (args
);
9001 if (level
<= levels
)
9003 arg
= TMPL_ARG (args
, level
, idx
);
9005 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
9006 /* See through ARGUMENT_PACK_SELECT arguments. */
9007 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
9010 if (arg
== error_mark_node
)
9011 return error_mark_node
;
9012 else if (arg
!= NULL_TREE
)
9014 if (ARGUMENT_PACK_P (arg
))
9015 /* If ARG is an argument pack, we don't actually want to
9016 perform a substitution here, because substitutions
9017 for argument packs are only done
9018 element-by-element. We can get to this point when
9019 substituting the type of a non-type template
9020 parameter pack, when that type actually contains
9021 template parameter packs from an outer template, e.g.,
9023 template<typename... Types> struct A {
9024 template<Types... Values> struct B { };
9028 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
9031 gcc_assert (TYPE_P (arg
));
9033 /* cv-quals from the template are discarded when
9034 substituting in a function or reference type. */
9035 if (TREE_CODE (arg
) == FUNCTION_TYPE
9036 || TREE_CODE (arg
) == METHOD_TYPE
9037 || TREE_CODE (arg
) == REFERENCE_TYPE
)
9038 quals
= cp_type_quals (arg
);
9040 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
9042 return cp_build_qualified_type_real
9043 (arg
, quals
, complain
| tf_ignore_bad_quals
);
9045 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
9047 /* We are processing a type constructed from a
9048 template template parameter. */
9049 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
9050 args
, complain
, in_decl
);
9051 if (argvec
== error_mark_node
)
9052 return error_mark_node
;
9054 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9055 are resolving nested-types in the signature of a
9056 member function templates. Otherwise ARG is a
9057 TEMPLATE_DECL and is the real template to be
9059 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
9060 arg
= TYPE_NAME (arg
);
9062 r
= lookup_template_class (arg
,
9065 /*entering_scope=*/0,
9067 return cp_build_qualified_type_real
9068 (r
, TYPE_QUALS (t
), complain
);
9071 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9076 /* This can happen during the attempted tsubst'ing in
9077 unify. This means that we don't yet have any information
9078 about the template parameter in question. */
9081 /* If we get here, we must have been looking at a parm for a
9082 more deeply nested template. Make a new version of this
9083 template parameter, but with a lower level. */
9084 switch (TREE_CODE (t
))
9086 case TEMPLATE_TYPE_PARM
:
9087 case TEMPLATE_TEMPLATE_PARM
:
9088 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9089 if (cp_type_quals (t
))
9091 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
9092 r
= cp_build_qualified_type_real
9093 (r
, cp_type_quals (t
),
9094 complain
| (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
9095 ? tf_ignore_bad_quals
: 0));
9100 TEMPLATE_TYPE_PARM_INDEX (r
)
9101 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
9102 r
, levels
, args
, complain
);
9103 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
9104 TYPE_MAIN_VARIANT (r
) = r
;
9105 TYPE_POINTER_TO (r
) = NULL_TREE
;
9106 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
9108 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
9109 /* We have reduced the level of the template
9110 template parameter, but not the levels of its
9111 template parameters, so canonical_type_parameter
9112 will not be able to find the canonical template
9113 template parameter for this level. Thus, we
9114 require structural equality checking to compare
9115 TEMPLATE_TEMPLATE_PARMs. */
9116 SET_TYPE_STRUCTURAL_EQUALITY (r
);
9117 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
9118 SET_TYPE_STRUCTURAL_EQUALITY (r
);
9120 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
9122 if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
9124 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
9126 if (argvec
== error_mark_node
)
9127 return error_mark_node
;
9129 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
9130 = tree_cons (TYPE_TI_TEMPLATE (t
), argvec
, NULL_TREE
);
9135 case TEMPLATE_PARM_INDEX
:
9136 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
9148 tree purpose
, value
, chain
;
9150 if (t
== void_list_node
)
9153 purpose
= TREE_PURPOSE (t
);
9156 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
9157 if (purpose
== error_mark_node
)
9158 return error_mark_node
;
9160 value
= TREE_VALUE (t
);
9163 value
= tsubst (value
, args
, complain
, in_decl
);
9164 if (value
== error_mark_node
)
9165 return error_mark_node
;
9167 chain
= TREE_CHAIN (t
);
9168 if (chain
&& chain
!= void_type_node
)
9170 chain
= tsubst (chain
, args
, complain
, in_decl
);
9171 if (chain
== error_mark_node
)
9172 return error_mark_node
;
9174 if (purpose
== TREE_PURPOSE (t
)
9175 && value
== TREE_VALUE (t
)
9176 && chain
== TREE_CHAIN (t
))
9178 return hash_tree_cons (purpose
, value
, chain
);
9182 /* We should never be tsubsting a binfo. */
9186 /* A vector of template arguments. */
9188 return tsubst_template_args (t
, args
, complain
, in_decl
);
9191 case REFERENCE_TYPE
:
9193 enum tree_code code
;
9195 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
9198 code
= TREE_CODE (t
);
9203 Type deduction may fail for any of the following
9206 -- Attempting to create a pointer to reference type.
9207 -- Attempting to create a reference to a reference type or
9208 a reference to void.
9210 Core issue 106 says that creating a reference to a reference
9211 during instantiation is no longer a cause for failure. We
9212 only enforce this check in strict C++98 mode. */
9213 if ((TREE_CODE (type
) == REFERENCE_TYPE
9214 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
9215 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
9217 static location_t last_loc
;
9219 /* We keep track of the last time we issued this error
9220 message to avoid spewing a ton of messages during a
9221 single bad template instantiation. */
9222 if (complain
& tf_error
9223 #ifdef USE_MAPPED_LOCATION
9224 && last_loc
!= input_location
9226 && (last_loc
.line
!= input_line
9227 || last_loc
.file
!= input_filename
)
9231 if (TREE_CODE (type
) == VOID_TYPE
)
9232 error ("forming reference to void");
9234 error ("forming %s to reference type %qT",
9235 (code
== POINTER_TYPE
) ? "pointer" : "reference",
9237 last_loc
= input_location
;
9240 return error_mark_node
;
9242 else if (code
== POINTER_TYPE
)
9244 r
= build_pointer_type (type
);
9245 if (TREE_CODE (type
) == METHOD_TYPE
)
9246 r
= build_ptrmemfunc_type (r
);
9248 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9249 /* In C++0x, during template argument substitution, when there is an
9250 attempt to create a reference to a reference type, reference
9251 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9253 "If a template-argument for a template-parameter T names a type
9254 that is a reference to a type A, an attempt to create the type
9255 'lvalue reference to cv T' creates the type 'lvalue reference to
9256 A,' while an attempt to create the type type rvalue reference to
9257 cv T' creates the type T"
9259 r
= cp_build_reference_type
9261 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
9263 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
9264 r
= cp_build_qualified_type_real (r
, TYPE_QUALS (t
), complain
);
9266 if (r
!= error_mark_node
)
9267 /* Will this ever be needed for TYPE_..._TO values? */
9274 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
9275 if (r
== error_mark_node
|| !IS_AGGR_TYPE (r
))
9279 Type deduction may fail for any of the following
9282 -- Attempting to create "pointer to member of T" when T
9283 is not a class type. */
9284 if (complain
& tf_error
)
9285 error ("creating pointer to member of non-class type %qT", r
);
9286 return error_mark_node
;
9288 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9290 if (complain
& tf_error
)
9291 error ("creating pointer to member reference type %qT", type
);
9292 return error_mark_node
;
9294 if (TREE_CODE (type
) == VOID_TYPE
)
9296 if (complain
& tf_error
)
9297 error ("creating pointer to member of type void");
9298 return error_mark_node
;
9300 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9301 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9303 /* The type of the implicit object parameter gets its
9304 cv-qualifiers from the FUNCTION_TYPE. */
9306 tree this_type
= cp_build_qualified_type (TYPE_MAIN_VARIANT (r
),
9307 cp_type_quals (type
));
9309 method_type
= build_method_type_directly (this_type
,
9311 TYPE_ARG_TYPES (type
));
9312 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
9313 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
9317 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
9326 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
9327 if (fntype
== error_mark_node
)
9328 return error_mark_node
;
9330 /* Substitute the exception specification. */
9331 specs
= tsubst_exception_specification (t
, args
, complain
,
9333 if (specs
== error_mark_node
)
9334 return error_mark_node
;
9336 fntype
= build_exception_variant (fntype
, specs
);
9341 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
9342 if (domain
== error_mark_node
)
9343 return error_mark_node
;
9345 /* As an optimization, we avoid regenerating the array type if
9346 it will obviously be the same as T. */
9347 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
9350 /* These checks should match the ones in grokdeclarator.
9354 The deduction may fail for any of the following reasons:
9356 -- Attempting to create an array with an element type that
9357 is void, a function type, or a reference type, or [DR337]
9358 an abstract class type. */
9359 if (TREE_CODE (type
) == VOID_TYPE
9360 || TREE_CODE (type
) == FUNCTION_TYPE
9361 || TREE_CODE (type
) == REFERENCE_TYPE
)
9363 if (complain
& tf_error
)
9364 error ("creating array of %qT", type
);
9365 return error_mark_node
;
9367 if (CLASS_TYPE_P (type
) && CLASSTYPE_PURE_VIRTUALS (type
))
9369 if (complain
& tf_error
)
9370 error ("creating array of %qT, which is an abstract class type",
9372 return error_mark_node
;
9375 r
= build_cplus_array_type (type
, domain
);
9377 if (TYPE_USER_ALIGN (t
))
9379 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
9380 TYPE_USER_ALIGN (r
) = 1;
9389 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9390 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
9392 if (e1
== error_mark_node
|| e2
== error_mark_node
)
9393 return error_mark_node
;
9395 return fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), e1
, e2
);
9401 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9402 if (e
== error_mark_node
)
9403 return error_mark_node
;
9405 return fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), e
);
9410 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
9411 in_decl
, /*entering_scope=*/1);
9412 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
9416 if (ctx
== error_mark_node
|| f
== error_mark_node
)
9417 return error_mark_node
;
9419 if (!IS_AGGR_TYPE (ctx
))
9421 if (complain
& tf_error
)
9422 error ("%qT is not a class, struct, or union type", ctx
);
9423 return error_mark_node
;
9425 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
9427 /* Normally, make_typename_type does not require that the CTX
9428 have complete type in order to allow things like:
9430 template <class T> struct S { typename S<T>::X Y; };
9432 But, such constructs have already been resolved by this
9433 point, so here CTX really should have complete type, unless
9434 it's a partial instantiation. */
9435 ctx
= complete_type (ctx
);
9436 if (!COMPLETE_TYPE_P (ctx
))
9438 if (complain
& tf_error
)
9439 cxx_incomplete_type_error (NULL_TREE
, ctx
);
9440 return error_mark_node
;
9444 f
= make_typename_type (ctx
, f
, typename_type
,
9445 (complain
& tf_error
) | tf_keep_type_decl
);
9446 if (f
== error_mark_node
)
9448 if (TREE_CODE (f
) == TYPE_DECL
)
9450 complain
|= tf_ignore_bad_quals
;
9454 if (TREE_CODE (f
) != TYPENAME_TYPE
)
9456 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
9457 error ("%qT resolves to %qT, which is not an enumeration type",
9459 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
9460 error ("%qT resolves to %qT, which is is not a class type",
9464 /* cv-quals from the template are discarded when
9465 substituting in a function or reference type. */
9466 if (TREE_CODE (f
) == FUNCTION_TYPE
9467 || TREE_CODE (f
) == METHOD_TYPE
9468 || TREE_CODE (f
) == REFERENCE_TYPE
)
9469 quals
= cp_type_quals (f
);
9471 quals
= cp_type_quals (f
) | cp_type_quals (t
);
9472 return cp_build_qualified_type_real (f
, quals
, complain
);
9475 case UNBOUND_CLASS_TEMPLATE
:
9477 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
9478 in_decl
, /*entering_scope=*/1);
9479 tree name
= TYPE_IDENTIFIER (t
);
9480 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
9482 if (ctx
== error_mark_node
|| name
== error_mark_node
)
9483 return error_mark_node
;
9486 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
9487 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
9497 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9498 tree e2
= tsubst_expr (TREE_OPERAND (t
, 1), args
, complain
, in_decl
,
9499 /*integral_constant_expression_p=*/false);
9500 if (e1
== error_mark_node
|| e2
== error_mark_node
)
9501 return error_mark_node
;
9503 return build_nt (ARRAY_REF
, e1
, e2
, NULL_TREE
, NULL_TREE
);
9508 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9509 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
9510 if (e1
== error_mark_node
|| e2
== error_mark_node
)
9511 return error_mark_node
;
9513 return build_qualified_name (/*type=*/NULL_TREE
,
9514 e1
, e2
, QUALIFIED_NAME_IS_TEMPLATE (t
));
9521 type
= finish_typeof (tsubst_expr
9522 (TYPEOF_TYPE_EXPR (t
), args
,
9524 /*integral_constant_expression_p=*/false));
9525 return cp_build_qualified_type_real (type
,
9527 | cp_type_quals (type
),
9536 finish_decltype_type (tsubst_expr
9537 (DECLTYPE_TYPE_EXPR (t
), args
,
9539 /*integral_constant_expression_p=*/false),
9540 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
));
9541 return cp_build_qualified_type_real (type
,
9543 | cp_type_quals (type
),
9547 case TYPE_ARGUMENT_PACK
:
9548 case NONTYPE_ARGUMENT_PACK
:
9550 tree r
= make_node (TREE_CODE (t
));
9552 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
9556 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
9558 /* For template nontype argument packs, also substitute into
9560 if (TREE_CODE (t
) == NONTYPE_ARGUMENT_PACK
)
9561 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
9568 sorry ("use of %qs in template",
9569 tree_code_name
[(int) TREE_CODE (t
)]);
9570 return error_mark_node
;
9574 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9575 type of the expression on the left-hand side of the "." or "->"
9579 tsubst_baselink (tree baselink
, tree object_type
,
9580 tree args
, tsubst_flags_t complain
, tree in_decl
)
9583 tree qualifying_scope
;
9586 tree template_args
= 0;
9587 bool template_id_p
= false;
9589 /* A baselink indicates a function from a base class. Both the
9590 BASELINK_ACCESS_BINFO and the base class referenced may
9591 indicate bases of the template class, rather than the
9592 instantiated class. In addition, lookups that were not
9593 ambiguous before may be ambiguous now. Therefore, we perform
9594 the lookup again. */
9595 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
9596 qualifying_scope
= tsubst (qualifying_scope
, args
,
9598 fns
= BASELINK_FUNCTIONS (baselink
);
9599 optype
= BASELINK_OPTYPE (baselink
);
9600 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
9602 template_id_p
= true;
9603 template_args
= TREE_OPERAND (fns
, 1);
9604 fns
= TREE_OPERAND (fns
, 0);
9606 template_args
= tsubst_template_args (template_args
, args
,
9609 name
= DECL_NAME (get_first_fn (fns
));
9610 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
9612 /* If lookup found a single function, mark it as used at this
9613 point. (If it lookup found multiple functions the one selected
9614 later by overload resolution will be marked as used at that
9616 if (BASELINK_P (baselink
))
9617 fns
= BASELINK_FUNCTIONS (baselink
);
9618 if (!template_id_p
&& !really_overloaded_fn (fns
))
9619 mark_used (OVL_CURRENT (fns
));
9621 /* Add back the template arguments, if present. */
9622 if (BASELINK_P (baselink
) && template_id_p
)
9623 BASELINK_FUNCTIONS (baselink
)
9624 = build_nt (TEMPLATE_ID_EXPR
,
9625 BASELINK_FUNCTIONS (baselink
),
9627 /* Update the conversion operator type. */
9628 BASELINK_OPTYPE (baselink
)
9629 = tsubst (optype
, args
, complain
, in_decl
);
9632 object_type
= current_class_type
;
9633 return adjust_result_of_qualified_name_lookup (baselink
,
9638 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9639 true if the qualified-id will be a postfix-expression in-and-of
9640 itself; false if more of the postfix-expression follows the
9641 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9645 tsubst_qualified_id (tree qualified_id
, tree args
,
9646 tsubst_flags_t complain
, tree in_decl
,
9647 bool done
, bool address_p
)
9655 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
9657 /* Figure out what name to look up. */
9658 name
= TREE_OPERAND (qualified_id
, 1);
9659 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
9662 template_args
= TREE_OPERAND (name
, 1);
9664 template_args
= tsubst_template_args (template_args
, args
,
9666 name
= TREE_OPERAND (name
, 0);
9670 is_template
= false;
9671 template_args
= NULL_TREE
;
9674 /* Substitute into the qualifying scope. When there are no ARGS, we
9675 are just trying to simplify a non-dependent expression. In that
9676 case the qualifying scope may be dependent, and, in any case,
9677 substituting will not help. */
9678 scope
= TREE_OPERAND (qualified_id
, 0);
9681 scope
= tsubst (scope
, args
, complain
, in_decl
);
9682 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
9687 if (dependent_type_p (scope
))
9688 return build_qualified_name (/*type=*/NULL_TREE
,
9690 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
9692 if (!BASELINK_P (name
) && !DECL_P (expr
))
9694 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
9695 /* If this were actually a destructor call, it would have been
9696 parsed as such by the parser. */
9697 expr
= error_mark_node
;
9699 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
9700 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
9701 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
9703 if (complain
& tf_error
)
9705 error ("dependent-name %qE is parsed as a non-type, but "
9706 "instantiation yields a type", qualified_id
);
9707 inform ("say %<typename %E%> if a type is meant", qualified_id
);
9709 return error_mark_node
;
9715 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
9717 /* Remember that there was a reference to this entity. */
9721 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
9723 if (complain
& tf_error
)
9724 qualified_name_lookup_error (scope
,
9725 TREE_OPERAND (qualified_id
, 1),
9727 return error_mark_node
;
9731 expr
= lookup_template_function (expr
, template_args
);
9733 if (expr
== error_mark_node
&& complain
& tf_error
)
9734 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
9736 else if (TYPE_P (scope
))
9738 expr
= (adjust_result_of_qualified_name_lookup
9739 (expr
, scope
, current_class_type
));
9740 expr
= (finish_qualified_id_expr
9741 (scope
, expr
, done
, address_p
,
9742 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
9743 /*template_arg_p=*/false));
9746 /* Expressions do not generally have reference type. */
9747 if (TREE_CODE (expr
) != SCOPE_REF
9748 /* However, if we're about to form a pointer-to-member, we just
9749 want the referenced member referenced. */
9750 && TREE_CODE (expr
) != OFFSET_REF
)
9751 expr
= convert_from_reference (expr
);
9756 /* Like tsubst, but deals with expressions. This function just replaces
9757 template parms; to finish processing the resultant expression, use
9761 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9763 enum tree_code code
;
9766 if (t
== NULL_TREE
|| t
== error_mark_node
)
9769 code
= TREE_CODE (t
);
9774 r
= retrieve_local_specialization (t
);
9775 gcc_assert (r
!= NULL
);
9776 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
9777 r
= ARGUMENT_PACK_SELECT_ARG (r
);
9786 if (DECL_TEMPLATE_PARM_P (t
))
9787 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
9788 /* There is no need to substitute into namespace-scope
9790 if (DECL_NAMESPACE_SCOPE_P (t
))
9792 /* If ARGS is NULL, then T is known to be non-dependent. */
9793 if (args
== NULL_TREE
)
9794 return integral_constant_value (t
);
9796 /* Unfortunately, we cannot just call lookup_name here.
9799 template <int I> int f() {
9801 struct S { void g() { E e = a; } };
9804 When we instantiate f<7>::S::g(), say, lookup_name is not
9805 clever enough to find f<7>::a. */
9807 = tsubst_aggr_type (TREE_TYPE (t
), args
, complain
, in_decl
,
9808 /*entering_scope=*/0);
9810 for (v
= TYPE_VALUES (enum_type
);
9813 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
9814 return TREE_VALUE (v
);
9816 /* We didn't find the name. That should never happen; if
9817 name-lookup found it during preliminary parsing, we
9818 should find it again here during instantiation. */
9824 if (DECL_CONTEXT (t
))
9828 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
9829 /*entering_scope=*/1);
9830 if (ctx
!= DECL_CONTEXT (t
))
9832 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
9835 if (complain
& tf_error
)
9836 error ("using invalid field %qD", t
);
9837 return error_mark_node
;
9847 if ((DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9848 || local_variable_p (t
))
9849 t
= tsubst (t
, args
, complain
, in_decl
);
9854 return tsubst_baselink (t
, current_class_type
, args
, complain
, in_decl
);
9857 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9858 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
9859 args
, complain
, in_decl
);
9860 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
9861 return tsubst (t
, args
, complain
, in_decl
);
9862 else if (DECL_CLASS_SCOPE_P (t
)
9863 && uses_template_parms (DECL_CONTEXT (t
)))
9865 /* Template template argument like the following example need
9868 template <template <class> class TT> struct C {};
9869 template <class T> struct D {
9870 template <class U> struct E {};
9875 We are processing the template argument `E' in #1 for
9876 the template instantiation #2. Originally, `E' is a
9877 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9878 have to substitute this with one having context `D<int>'. */
9880 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
9881 return lookup_field (context
, DECL_NAME(t
), 0, false);
9884 /* Ordinary template template argument. */
9888 case REINTERPRET_CAST_EXPR
:
9889 case CONST_CAST_EXPR
:
9890 case STATIC_CAST_EXPR
:
9891 case DYNAMIC_CAST_EXPR
:
9894 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
9895 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
9898 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
9900 /* We only want to compute the number of arguments. */
9901 tree expanded
= tsubst_pack_expansion (TREE_OPERAND (t
, 0), args
,
9903 if (expanded
== error_mark_node
)
9904 return error_mark_node
;
9905 return build_int_cst (size_type_node
, TREE_VEC_LENGTH (expanded
));
9911 case TRUTH_NOT_EXPR
:
9914 case UNARY_PLUS_EXPR
: /* Unary + */
9922 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
9923 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
9930 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9931 name
= TREE_OPERAND (t
, 1);
9932 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
9934 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9936 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
9938 else if (TREE_CODE (name
) == SCOPE_REF
9939 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
9941 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9943 name
= TREE_OPERAND (name
, 1);
9944 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9946 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
9947 name
= build_qualified_name (/*type=*/NULL_TREE
,
9949 /*template_p=*/false);
9951 else if (TREE_CODE (name
) == BASELINK
)
9952 name
= tsubst_baselink (name
,
9953 non_reference (TREE_TYPE (object
)),
9957 name
= tsubst_copy (name
, args
, complain
, in_decl
);
9958 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
9964 case TRUNC_DIV_EXPR
:
9966 case FLOOR_DIV_EXPR
:
9967 case ROUND_DIV_EXPR
:
9968 case EXACT_DIV_EXPR
:
9972 case TRUNC_MOD_EXPR
:
9973 case FLOOR_MOD_EXPR
:
9974 case TRUTH_ANDIF_EXPR
:
9975 case TRUTH_ORIF_EXPR
:
9976 case TRUTH_AND_EXPR
:
9993 case PREDECREMENT_EXPR
:
9994 case PREINCREMENT_EXPR
:
9995 case POSTDECREMENT_EXPR
:
9996 case POSTINCREMENT_EXPR
:
9998 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
9999 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
10002 return build_qualified_name (/*type=*/NULL_TREE
,
10003 tsubst_copy (TREE_OPERAND (t
, 0),
10004 args
, complain
, in_decl
),
10005 tsubst_copy (TREE_OPERAND (t
, 1),
10006 args
, complain
, in_decl
),
10007 QUALIFIED_NAME_IS_TEMPLATE (t
));
10012 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10013 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
10014 NULL_TREE
, NULL_TREE
);
10018 int n
= VL_EXP_OPERAND_LENGTH (t
);
10019 tree result
= build_vl_exp (CALL_EXPR
, n
);
10021 for (i
= 0; i
< n
; i
++)
10022 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
10023 complain
, in_decl
);
10029 case PSEUDO_DTOR_EXPR
:
10032 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10033 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
10034 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
10035 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
10042 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10043 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
10044 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
10045 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
10052 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10053 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
10054 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
10055 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
10059 case TEMPLATE_ID_EXPR
:
10061 /* Substituted template arguments */
10062 tree fn
= TREE_OPERAND (t
, 0);
10063 tree targs
= TREE_OPERAND (t
, 1);
10065 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
10067 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
10069 return lookup_template_function (fn
, targs
);
10074 tree purpose
, value
, chain
;
10076 if (t
== void_list_node
)
10079 purpose
= TREE_PURPOSE (t
);
10081 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
10082 value
= TREE_VALUE (t
);
10084 value
= tsubst_copy (value
, args
, complain
, in_decl
);
10085 chain
= TREE_CHAIN (t
);
10086 if (chain
&& chain
!= void_type_node
)
10087 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
10088 if (purpose
== TREE_PURPOSE (t
)
10089 && value
== TREE_VALUE (t
)
10090 && chain
== TREE_CHAIN (t
))
10092 return tree_cons (purpose
, value
, chain
);
10097 case ENUMERAL_TYPE
:
10099 case TEMPLATE_TYPE_PARM
:
10100 case TEMPLATE_TEMPLATE_PARM
:
10101 case BOUND_TEMPLATE_TEMPLATE_PARM
:
10102 case TEMPLATE_PARM_INDEX
:
10104 case REFERENCE_TYPE
:
10106 case FUNCTION_TYPE
:
10109 case TYPENAME_TYPE
:
10110 case UNBOUND_CLASS_TEMPLATE
:
10112 case DECLTYPE_TYPE
:
10114 return tsubst (t
, args
, complain
, in_decl
);
10116 case IDENTIFIER_NODE
:
10117 if (IDENTIFIER_TYPENAME_P (t
))
10119 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10120 return mangle_conv_op_name_for_type (new_type
);
10126 /* This is handled by tsubst_copy_and_build. */
10127 gcc_unreachable ();
10130 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
10132 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
10134 case CLEANUP_POINT_EXPR
:
10135 /* We shouldn't have built any of these during initial template
10136 generation. Instead, they should be built during instantiation
10137 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10138 gcc_unreachable ();
10141 mark_used (TREE_OPERAND (t
, 1));
10144 case EXPR_PACK_EXPANSION
:
10145 error ("invalid use of pack expansion expression");
10146 return error_mark_node
;
10148 case NONTYPE_ARGUMENT_PACK
:
10149 error ("use %<...%> to expand argument pack");
10150 return error_mark_node
;
10157 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10160 tsubst_omp_clauses (tree clauses
, tree args
, tsubst_flags_t complain
,
10163 tree new_clauses
= NULL
, nc
, oc
;
10165 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
10167 nc
= copy_node (oc
);
10168 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
10171 switch (OMP_CLAUSE_CODE (nc
))
10173 case OMP_CLAUSE_PRIVATE
:
10174 case OMP_CLAUSE_SHARED
:
10175 case OMP_CLAUSE_FIRSTPRIVATE
:
10176 case OMP_CLAUSE_LASTPRIVATE
:
10177 case OMP_CLAUSE_REDUCTION
:
10178 case OMP_CLAUSE_COPYIN
:
10179 case OMP_CLAUSE_COPYPRIVATE
:
10180 case OMP_CLAUSE_IF
:
10181 case OMP_CLAUSE_NUM_THREADS
:
10182 case OMP_CLAUSE_SCHEDULE
:
10183 OMP_CLAUSE_OPERAND (nc
, 0)
10184 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
10185 in_decl
, /*integral_constant_expression_p=*/false);
10187 case OMP_CLAUSE_NOWAIT
:
10188 case OMP_CLAUSE_ORDERED
:
10189 case OMP_CLAUSE_DEFAULT
:
10192 gcc_unreachable ();
10196 return finish_omp_clauses (nreverse (new_clauses
));
10199 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10202 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
10205 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10207 tree purpose
, value
, chain
;
10212 if (TREE_CODE (t
) != TREE_LIST
)
10213 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
10214 /*function_p=*/false,
10215 /*integral_constant_expression_p=*/false);
10217 if (t
== void_list_node
)
10220 purpose
= TREE_PURPOSE (t
);
10222 purpose
= RECUR (purpose
);
10223 value
= TREE_VALUE (t
);
10225 value
= RECUR (value
);
10226 chain
= TREE_CHAIN (t
);
10227 if (chain
&& chain
!= void_type_node
)
10228 chain
= RECUR (chain
);
10229 return tree_cons (purpose
, value
, chain
);
10233 /* Like tsubst_copy for expressions, etc. but also does semantic
10237 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
10238 bool integral_constant_expression_p
)
10240 #define RECUR(NODE) \
10241 tsubst_expr ((NODE), args, complain, in_decl, \
10242 integral_constant_expression_p)
10246 if (t
== NULL_TREE
|| t
== error_mark_node
)
10249 if (EXPR_HAS_LOCATION (t
))
10250 input_location
= EXPR_LOCATION (t
);
10251 if (STATEMENT_CODE_P (TREE_CODE (t
)))
10252 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
10254 switch (TREE_CODE (t
))
10256 case STATEMENT_LIST
:
10258 tree_stmt_iterator i
;
10259 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
10260 RECUR (tsi_stmt (i
));
10264 case CTOR_INITIALIZER
:
10265 finish_mem_initializers (tsubst_initializer_list
10266 (TREE_OPERAND (t
, 0), args
));
10270 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
10274 tmp
= RECUR (EXPR_STMT_EXPR (t
));
10275 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
10276 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
10278 finish_expr_stmt (tmp
);
10282 do_using_directive (RECUR (USING_STMT_NAMESPACE (t
)));
10290 decl
= DECL_EXPR_DECL (t
);
10291 if (TREE_CODE (decl
) == LABEL_DECL
)
10292 finish_label_decl (DECL_NAME (decl
));
10293 else if (TREE_CODE (decl
) == USING_DECL
)
10295 tree scope
= USING_DECL_SCOPE (decl
);
10296 tree name
= DECL_NAME (decl
);
10299 scope
= RECUR (scope
);
10300 decl
= lookup_qualified_name (scope
, name
,
10301 /*is_type_p=*/false,
10302 /*complain=*/false);
10303 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
10304 qualified_name_lookup_error (scope
, name
, decl
);
10306 do_local_using_decl (decl
, scope
, name
);
10310 init
= DECL_INITIAL (decl
);
10311 decl
= tsubst (decl
, args
, complain
, in_decl
);
10312 if (decl
!= error_mark_node
)
10314 /* By marking the declaration as instantiated, we avoid
10315 trying to instantiate it. Since instantiate_decl can't
10316 handle local variables, and since we've already done
10317 all that needs to be done, that's the right thing to
10319 if (TREE_CODE (decl
) == VAR_DECL
)
10320 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
10321 if (TREE_CODE (decl
) == VAR_DECL
10322 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
10323 /* Anonymous aggregates are a special case. */
10324 finish_anon_union (decl
);
10327 maybe_push_decl (decl
);
10328 if (TREE_CODE (decl
) == VAR_DECL
10329 && DECL_PRETTY_FUNCTION_P (decl
))
10331 /* For __PRETTY_FUNCTION__ we have to adjust the
10333 const char *const name
10334 = cxx_printable_name (current_function_decl
, 2);
10335 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
10339 tree t
= RECUR (init
);
10342 /* If we had an initializer but it
10343 instantiated to nothing,
10344 value-initialize the object. This will
10345 only occur when the initializer was a
10346 pack expansion where the parameter packs
10347 used in that expansion were of length
10349 init
= build_default_init (TREE_TYPE (decl
),
10355 finish_decl (decl
, init
, NULL_TREE
);
10360 /* A DECL_EXPR can also be used as an expression, in the condition
10361 clause of an if/for/while construct. */
10366 stmt
= begin_for_stmt ();
10367 RECUR (FOR_INIT_STMT (t
));
10368 finish_for_init_stmt (stmt
);
10369 tmp
= RECUR (FOR_COND (t
));
10370 finish_for_cond (tmp
, stmt
);
10371 tmp
= RECUR (FOR_EXPR (t
));
10372 finish_for_expr (tmp
, stmt
);
10373 RECUR (FOR_BODY (t
));
10374 finish_for_stmt (stmt
);
10378 stmt
= begin_while_stmt ();
10379 tmp
= RECUR (WHILE_COND (t
));
10380 finish_while_stmt_cond (tmp
, stmt
);
10381 RECUR (WHILE_BODY (t
));
10382 finish_while_stmt (stmt
);
10386 stmt
= begin_do_stmt ();
10387 RECUR (DO_BODY (t
));
10388 finish_do_body (stmt
);
10389 tmp
= RECUR (DO_COND (t
));
10390 finish_do_stmt (tmp
, stmt
);
10394 stmt
= begin_if_stmt ();
10395 tmp
= RECUR (IF_COND (t
));
10396 finish_if_stmt_cond (tmp
, stmt
);
10397 RECUR (THEN_CLAUSE (t
));
10398 finish_then_clause (stmt
);
10400 if (ELSE_CLAUSE (t
))
10402 begin_else_clause (stmt
);
10403 RECUR (ELSE_CLAUSE (t
));
10404 finish_else_clause (stmt
);
10407 finish_if_stmt (stmt
);
10411 if (BIND_EXPR_BODY_BLOCK (t
))
10412 stmt
= begin_function_body ();
10414 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
10415 ? BCS_TRY_BLOCK
: 0);
10417 RECUR (BIND_EXPR_BODY (t
));
10419 if (BIND_EXPR_BODY_BLOCK (t
))
10420 finish_function_body (stmt
);
10422 finish_compound_stmt (stmt
);
10426 finish_break_stmt ();
10429 case CONTINUE_STMT
:
10430 finish_continue_stmt ();
10434 stmt
= begin_switch_stmt ();
10435 tmp
= RECUR (SWITCH_STMT_COND (t
));
10436 finish_switch_cond (tmp
, stmt
);
10437 RECUR (SWITCH_STMT_BODY (t
));
10438 finish_switch_stmt (stmt
);
10441 case CASE_LABEL_EXPR
:
10442 finish_case_label (RECUR (CASE_LOW (t
)),
10443 RECUR (CASE_HIGH (t
)));
10447 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t
)));
10451 tmp
= GOTO_DESTINATION (t
);
10452 if (TREE_CODE (tmp
) != LABEL_DECL
)
10453 /* Computed goto's must be tsubst'd into. On the other hand,
10454 non-computed gotos must not be; the identifier in question
10455 will have no binding. */
10458 tmp
= DECL_NAME (tmp
);
10459 finish_goto_stmt (tmp
);
10463 tmp
= finish_asm_stmt
10464 (ASM_VOLATILE_P (t
),
10465 RECUR (ASM_STRING (t
)),
10466 tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
10467 tsubst_copy_asm_operands (ASM_INPUTS (t
), args
, complain
, in_decl
),
10468 tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
, complain
, in_decl
));
10470 tree asm_expr
= tmp
;
10471 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
10472 asm_expr
= TREE_OPERAND (asm_expr
, 0);
10473 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
10480 stmt
= begin_try_block ();
10481 RECUR (TRY_STMTS (t
));
10482 finish_cleanup_try_block (stmt
);
10483 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
10487 tree compound_stmt
= NULL_TREE
;
10489 if (FN_TRY_BLOCK_P (t
))
10490 stmt
= begin_function_try_block (&compound_stmt
);
10492 stmt
= begin_try_block ();
10494 RECUR (TRY_STMTS (t
));
10496 if (FN_TRY_BLOCK_P (t
))
10497 finish_function_try_block (stmt
);
10499 finish_try_block (stmt
);
10501 RECUR (TRY_HANDLERS (t
));
10502 if (FN_TRY_BLOCK_P (t
))
10503 finish_function_handler_sequence (stmt
, compound_stmt
);
10505 finish_handler_sequence (stmt
);
10511 tree decl
= HANDLER_PARMS (t
);
10515 decl
= tsubst (decl
, args
, complain
, in_decl
);
10516 /* Prevent instantiate_decl from trying to instantiate
10517 this variable. We've already done all that needs to be
10519 if (decl
!= error_mark_node
)
10520 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
10522 stmt
= begin_handler ();
10523 finish_handler_parms (decl
, stmt
);
10524 RECUR (HANDLER_BODY (t
));
10525 finish_handler (stmt
);
10530 tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
10533 case STATIC_ASSERT
:
10536 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
10539 /*integral_constant_expression_p=*/true);
10540 finish_static_assert (condition
,
10541 STATIC_ASSERT_MESSAGE (t
),
10542 STATIC_ASSERT_SOURCE_LOCATION (t
),
10543 /*member_p=*/false);
10548 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
),
10549 args
, complain
, in_decl
);
10550 stmt
= begin_omp_parallel ();
10551 RECUR (OMP_PARALLEL_BODY (t
));
10552 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
10553 = OMP_PARALLEL_COMBINED (t
);
10558 tree clauses
, decl
, init
, cond
, incr
, body
, pre_body
;
10560 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
),
10561 args
, complain
, in_decl
);
10562 init
= OMP_FOR_INIT (t
);
10563 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
10564 decl
= RECUR (TREE_OPERAND (init
, 0));
10565 init
= RECUR (TREE_OPERAND (init
, 1));
10566 cond
= RECUR (OMP_FOR_COND (t
));
10567 incr
= RECUR (OMP_FOR_INCR (t
));
10569 stmt
= begin_omp_structured_block ();
10571 pre_body
= push_stmt_list ();
10572 RECUR (OMP_FOR_PRE_BODY (t
));
10573 pre_body
= pop_stmt_list (pre_body
);
10575 body
= push_stmt_list ();
10576 RECUR (OMP_FOR_BODY (t
));
10577 body
= pop_stmt_list (body
);
10579 t
= finish_omp_for (EXPR_LOCATION (t
), decl
, init
, cond
, incr
, body
,
10582 OMP_FOR_CLAUSES (t
) = clauses
;
10584 add_stmt (finish_omp_structured_block (stmt
));
10590 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), args
, complain
, in_decl
);
10591 stmt
= push_stmt_list ();
10592 RECUR (OMP_BODY (t
));
10593 stmt
= pop_stmt_list (stmt
);
10596 OMP_BODY (t
) = stmt
;
10597 OMP_CLAUSES (t
) = tmp
;
10605 stmt
= push_stmt_list ();
10606 RECUR (OMP_BODY (t
));
10607 stmt
= pop_stmt_list (stmt
);
10610 OMP_BODY (t
) = stmt
;
10615 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
10617 tree op1
= TREE_OPERAND (t
, 1);
10618 tree lhs
= RECUR (TREE_OPERAND (op1
, 0));
10619 tree rhs
= RECUR (TREE_OPERAND (op1
, 1));
10620 finish_omp_atomic (TREE_CODE (op1
), lhs
, rhs
);
10624 case EXPR_PACK_EXPANSION
:
10625 error ("invalid use of pack expansion expression");
10626 return error_mark_node
;
10628 case NONTYPE_ARGUMENT_PACK
:
10629 error ("use %<...%> to expand argument pack");
10630 return error_mark_node
;
10633 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
10635 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
10636 /*function_p=*/false,
10637 integral_constant_expression_p
);
10644 /* T is a postfix-expression that is not being used in a function
10645 call. Return the substituted version of T. */
10648 tsubst_non_call_postfix_expression (tree t
, tree args
,
10649 tsubst_flags_t complain
,
10652 if (TREE_CODE (t
) == SCOPE_REF
)
10653 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
10654 /*done=*/false, /*address_p=*/false);
10656 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
10657 /*function_p=*/false,
10658 /*integral_constant_expression_p=*/false);
10663 /* Like tsubst but deals with expressions and performs semantic
10664 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10667 tsubst_copy_and_build (tree t
,
10669 tsubst_flags_t complain
,
10672 bool integral_constant_expression_p
)
10674 #define RECUR(NODE) \
10675 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10676 /*function_p=*/false, \
10677 integral_constant_expression_p)
10681 if (t
== NULL_TREE
|| t
== error_mark_node
)
10684 switch (TREE_CODE (t
))
10688 /* Fall through. */
10689 case IDENTIFIER_NODE
:
10693 bool non_integral_constant_expression_p
;
10694 const char *error_msg
;
10696 if (IDENTIFIER_TYPENAME_P (t
))
10698 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10699 t
= mangle_conv_op_name_for_type (new_type
);
10702 /* Look up the name. */
10703 decl
= lookup_name (t
);
10705 /* By convention, expressions use ERROR_MARK_NODE to indicate
10706 failure, not NULL_TREE. */
10707 if (decl
== NULL_TREE
)
10708 decl
= error_mark_node
;
10710 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
10712 integral_constant_expression_p
,
10713 /*allow_non_integral_constant_expression_p=*/false,
10714 &non_integral_constant_expression_p
,
10715 /*template_p=*/false,
10717 /*address_p=*/false,
10718 /*template_arg_p=*/false,
10722 if (!function_p
&& TREE_CODE (decl
) == IDENTIFIER_NODE
)
10723 decl
= unqualified_name_lookup_error (decl
);
10727 case TEMPLATE_ID_EXPR
:
10730 tree
template = RECUR (TREE_OPERAND (t
, 0));
10731 tree targs
= TREE_OPERAND (t
, 1);
10734 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
10736 if (TREE_CODE (template) == COMPONENT_REF
)
10738 object
= TREE_OPERAND (template, 0);
10739 template = TREE_OPERAND (template, 1);
10742 object
= NULL_TREE
;
10743 template = lookup_template_function (template, targs
);
10746 return build3 (COMPONENT_REF
, TREE_TYPE (template),
10747 object
, template, NULL_TREE
);
10749 return baselink_for_fns (template);
10754 tree r
= RECUR (TREE_OPERAND (t
, 0));
10756 if (REFERENCE_REF_P (t
))
10758 /* A type conversion to reference type will be enclosed in
10759 such an indirect ref, but the substitution of the cast
10760 will have also added such an indirect ref. */
10761 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
10762 r
= convert_from_reference (r
);
10765 r
= build_x_indirect_ref (r
, "unary *");
10771 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
10772 RECUR (TREE_OPERAND (t
, 0)));
10775 case REINTERPRET_CAST_EXPR
:
10776 case CONST_CAST_EXPR
:
10777 case DYNAMIC_CAST_EXPR
:
10778 case STATIC_CAST_EXPR
:
10783 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10784 if (integral_constant_expression_p
10785 && !cast_valid_in_integral_constant_expression_p (type
))
10787 error ("a cast to a type other than an integral or "
10788 "enumeration type cannot appear in a constant-expression");
10789 return error_mark_node
;
10792 op
= RECUR (TREE_OPERAND (t
, 0));
10794 switch (TREE_CODE (t
))
10797 return build_functional_cast (type
, op
);
10798 case REINTERPRET_CAST_EXPR
:
10799 return build_reinterpret_cast (type
, op
);
10800 case CONST_CAST_EXPR
:
10801 return build_const_cast (type
, op
);
10802 case DYNAMIC_CAST_EXPR
:
10803 return build_dynamic_cast (type
, op
);
10804 case STATIC_CAST_EXPR
:
10805 return build_static_cast (type
, op
);
10807 gcc_unreachable ();
10811 case POSTDECREMENT_EXPR
:
10812 case POSTINCREMENT_EXPR
:
10813 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10814 args
, complain
, in_decl
);
10815 return build_x_unary_op (TREE_CODE (t
), op1
);
10817 case PREDECREMENT_EXPR
:
10818 case PREINCREMENT_EXPR
:
10822 case TRUTH_NOT_EXPR
:
10823 case UNARY_PLUS_EXPR
: /* Unary + */
10824 case REALPART_EXPR
:
10825 case IMAGPART_EXPR
:
10826 return build_x_unary_op (TREE_CODE (t
), RECUR (TREE_OPERAND (t
, 0)));
10829 op1
= TREE_OPERAND (t
, 0);
10830 if (TREE_CODE (op1
) == SCOPE_REF
)
10831 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
10832 /*done=*/true, /*address_p=*/true);
10834 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
10836 if (TREE_CODE (op1
) == LABEL_DECL
)
10837 return finish_label_address_expr (DECL_NAME (op1
));
10838 return build_x_unary_op (ADDR_EXPR
, op1
);
10843 case TRUNC_DIV_EXPR
:
10844 case CEIL_DIV_EXPR
:
10845 case FLOOR_DIV_EXPR
:
10846 case ROUND_DIV_EXPR
:
10847 case EXACT_DIV_EXPR
:
10851 case TRUNC_MOD_EXPR
:
10852 case FLOOR_MOD_EXPR
:
10853 case TRUTH_ANDIF_EXPR
:
10854 case TRUTH_ORIF_EXPR
:
10855 case TRUTH_AND_EXPR
:
10856 case TRUTH_OR_EXPR
:
10871 return build_x_binary_op
10873 RECUR (TREE_OPERAND (t
, 0)),
10874 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
10876 : TREE_CODE (TREE_OPERAND (t
, 0))),
10877 RECUR (TREE_OPERAND (t
, 1)),
10878 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
10880 : TREE_CODE (TREE_OPERAND (t
, 1))),
10881 /*overloaded_p=*/NULL
);
10884 return tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
10885 /*address_p=*/false);
10887 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10888 args
, complain
, in_decl
);
10889 return build_x_binary_op (ARRAY_REF
, op1
,
10890 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
10892 : TREE_CODE (TREE_OPERAND (t
, 0))),
10893 RECUR (TREE_OPERAND (t
, 1)),
10894 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
10896 : TREE_CODE (TREE_OPERAND (t
, 1))),
10897 /*overloaded_p=*/NULL
);
10900 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
10902 /* We only want to compute the number of arguments. */
10903 tree expanded
= tsubst_pack_expansion (TREE_OPERAND (t
, 0), args
,
10904 complain
, in_decl
);
10905 if (expanded
== error_mark_node
)
10906 return error_mark_node
;
10907 return build_int_cst (size_type_node
, TREE_VEC_LENGTH (expanded
));
10912 op1
= TREE_OPERAND (t
, 0);
10915 /* When there are no ARGS, we are trying to evaluate a
10916 non-dependent expression from the parser. Trying to do
10917 the substitutions may not work. */
10919 op1
= TREE_TYPE (op1
);
10924 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
10925 /*function_p=*/false,
10926 /*integral_constant_expression_p=*/false);
10930 return cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
), true);
10932 return cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
));
10936 tree r
= build_x_modify_expr
10937 (RECUR (TREE_OPERAND (t
, 0)),
10938 TREE_CODE (TREE_OPERAND (t
, 1)),
10939 RECUR (TREE_OPERAND (t
, 2)));
10940 /* TREE_NO_WARNING must be set if either the expression was
10941 parenthesized or it uses an operator such as >>= rather
10942 than plain assignment. In the former case, it was already
10943 set and must be copied. In the latter case,
10944 build_x_modify_expr sets it and it must not be reset
10946 if (TREE_NO_WARNING (t
))
10947 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
10952 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10953 args
, complain
, in_decl
);
10954 /* Remember that there was a reference to this entity. */
10957 return build_x_arrow (op1
);
10961 tree init
= RECUR (TREE_OPERAND (t
, 3));
10963 if (TREE_OPERAND (t
, 3) && !init
)
10964 /* If there was an initializer in the the original tree, but
10965 it instantiated to an empty list, then we should pass on
10966 VOID_ZERO_NODE to tell build_new that it was an empty
10967 initializer () rather than no initializer. This can only
10968 happen when the initializer is a pack expansion whose
10969 parameter packs are of length zero. */
10970 init
= void_zero_node
;
10973 (RECUR (TREE_OPERAND (t
, 0)),
10974 RECUR (TREE_OPERAND (t
, 1)),
10975 RECUR (TREE_OPERAND (t
, 2)),
10977 NEW_EXPR_USE_GLOBAL (t
));
10981 return delete_sanity
10982 (RECUR (TREE_OPERAND (t
, 0)),
10983 RECUR (TREE_OPERAND (t
, 1)),
10984 DELETE_EXPR_USE_VEC (t
),
10985 DELETE_EXPR_USE_GLOBAL (t
));
10987 case COMPOUND_EXPR
:
10988 return build_x_compound_expr (RECUR (TREE_OPERAND (t
, 0)),
10989 RECUR (TREE_OPERAND (t
, 1)));
10998 function
= CALL_EXPR_FN (t
);
10999 /* When we parsed the expression, we determined whether or
11000 not Koenig lookup should be performed. */
11001 koenig_p
= KOENIG_LOOKUP_P (t
);
11002 if (TREE_CODE (function
) == SCOPE_REF
)
11004 qualified_p
= true;
11005 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
11007 /*address_p=*/false);
11011 if (TREE_CODE (function
) == COMPONENT_REF
)
11013 tree op
= TREE_OPERAND (function
, 1);
11015 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
11016 || (BASELINK_P (op
)
11017 && BASELINK_QUALIFIED_P (op
)));
11020 qualified_p
= false;
11022 function
= tsubst_copy_and_build (function
, args
, complain
,
11025 integral_constant_expression_p
);
11027 if (BASELINK_P (function
))
11028 qualified_p
= true;
11031 /* FIXME: Rewrite this so as not to construct an arglist. */
11032 call_args
= RECUR (CALL_EXPR_ARGS (t
));
11034 /* We do not perform argument-dependent lookup if normal
11035 lookup finds a non-function, in accordance with the
11036 expected resolution of DR 218. */
11038 && ((is_overloaded_fn (function
)
11039 /* If lookup found a member function, the Koenig lookup is
11040 not appropriate, even if an unqualified-name was used
11041 to denote the function. */
11042 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
11043 || TREE_CODE (function
) == IDENTIFIER_NODE
)
11044 /* Only do this when substitution turns a dependent call
11045 into a non-dependent call. */
11046 && type_dependent_expression_p_push (t
)
11047 && !any_type_dependent_arguments_p (call_args
))
11048 function
= perform_koenig_lookup (function
, call_args
);
11050 if (TREE_CODE (function
) == IDENTIFIER_NODE
)
11052 unqualified_name_lookup_error (function
);
11053 return error_mark_node
;
11056 /* Remember that there was a reference to this entity. */
11057 if (DECL_P (function
))
11058 mark_used (function
);
11060 if (TREE_CODE (function
) == OFFSET_REF
)
11061 return build_offset_ref_call_from_tree (function
, call_args
);
11062 if (TREE_CODE (function
) == COMPONENT_REF
)
11064 if (!BASELINK_P (TREE_OPERAND (function
, 1)))
11065 return finish_call_expr (function
, call_args
,
11066 /*disallow_virtual=*/false,
11067 /*koenig_p=*/false);
11069 return (build_new_method_call
11070 (TREE_OPERAND (function
, 0),
11071 TREE_OPERAND (function
, 1),
11072 call_args
, NULL_TREE
,
11073 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
11076 return finish_call_expr (function
, call_args
,
11077 /*disallow_virtual=*/qualified_p
,
11082 return build_x_conditional_expr
11083 (RECUR (TREE_OPERAND (t
, 0)),
11084 RECUR (TREE_OPERAND (t
, 1)),
11085 RECUR (TREE_OPERAND (t
, 2)));
11087 case PSEUDO_DTOR_EXPR
:
11088 return finish_pseudo_destructor_expr
11089 (RECUR (TREE_OPERAND (t
, 0)),
11090 RECUR (TREE_OPERAND (t
, 1)),
11091 RECUR (TREE_OPERAND (t
, 2)));
11095 tree purpose
, value
, chain
;
11097 if (t
== void_list_node
)
11100 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
11101 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
11103 /* We have pack expansions, so expand those and
11104 create a new list out of it. */
11105 tree purposevec
= NULL_TREE
;
11106 tree valuevec
= NULL_TREE
;
11110 /* Expand the argument expressions. */
11111 if (TREE_PURPOSE (t
))
11112 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
11113 complain
, in_decl
);
11114 if (TREE_VALUE (t
))
11115 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
11116 complain
, in_decl
);
11118 /* Build the rest of the list. */
11119 chain
= TREE_CHAIN (t
);
11120 if (chain
&& chain
!= void_type_node
)
11121 chain
= RECUR (chain
);
11123 /* Determine the number of arguments. */
11124 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
11126 len
= TREE_VEC_LENGTH (purposevec
);
11127 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
11129 else if (TREE_CODE (valuevec
) == TREE_VEC
)
11130 len
= TREE_VEC_LENGTH (valuevec
);
11133 /* Since we only performed a partial substitution into
11134 the argument pack, we only return a single list
11136 if (purposevec
== TREE_PURPOSE (t
)
11137 && valuevec
== TREE_VALUE (t
)
11138 && chain
== TREE_CHAIN (t
))
11141 return tree_cons (purposevec
, valuevec
, chain
);
11144 /* Convert the argument vectors into a TREE_LIST */
11148 /* Grab the Ith values. */
11150 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
11153 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
11156 /* Build the list (backwards). */
11157 chain
= tree_cons (purpose
, value
, chain
);
11163 purpose
= TREE_PURPOSE (t
);
11165 purpose
= RECUR (purpose
);
11166 value
= TREE_VALUE (t
);
11168 value
= RECUR (value
);
11169 chain
= TREE_CHAIN (t
);
11170 if (chain
&& chain
!= void_type_node
)
11171 chain
= RECUR (chain
);
11172 if (purpose
== TREE_PURPOSE (t
)
11173 && value
== TREE_VALUE (t
)
11174 && chain
== TREE_CHAIN (t
))
11176 return tree_cons (purpose
, value
, chain
);
11179 case COMPONENT_REF
:
11185 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
11186 args
, complain
, in_decl
);
11187 /* Remember that there was a reference to this entity. */
11188 if (DECL_P (object
))
11189 mark_used (object
);
11190 object_type
= TREE_TYPE (object
);
11192 member
= TREE_OPERAND (t
, 1);
11193 if (BASELINK_P (member
))
11194 member
= tsubst_baselink (member
,
11195 non_reference (TREE_TYPE (object
)),
11196 args
, complain
, in_decl
);
11198 member
= tsubst_copy (member
, args
, complain
, in_decl
);
11199 if (member
== error_mark_node
)
11200 return error_mark_node
;
11202 if (object_type
&& !CLASS_TYPE_P (object_type
))
11204 if (SCALAR_TYPE_P (object_type
))
11206 tree s
= NULL_TREE
;
11207 tree dtor
= member
;
11209 if (TREE_CODE (dtor
) == SCOPE_REF
)
11211 s
= TREE_OPERAND (dtor
, 0);
11212 dtor
= TREE_OPERAND (dtor
, 1);
11214 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
11216 dtor
= TREE_OPERAND (dtor
, 0);
11218 return finish_pseudo_destructor_expr (object
, s
, dtor
);
11222 else if (TREE_CODE (member
) == SCOPE_REF
11223 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
11228 /* Lookup the template functions now that we know what the
11230 tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
11231 args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
11232 member
= lookup_qualified_name (TREE_OPERAND (member
, 0), tmpl
,
11233 /*is_type_p=*/false,
11234 /*complain=*/false);
11235 if (BASELINK_P (member
))
11237 BASELINK_FUNCTIONS (member
)
11238 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
11240 member
= (adjust_result_of_qualified_name_lookup
11241 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
11246 qualified_name_lookup_error (object_type
, tmpl
, member
);
11247 return error_mark_node
;
11250 else if (TREE_CODE (member
) == SCOPE_REF
11251 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
11252 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
11254 if (complain
& tf_error
)
11256 if (TYPE_P (TREE_OPERAND (member
, 0)))
11257 error ("%qT is not a class or namespace",
11258 TREE_OPERAND (member
, 0));
11260 error ("%qD is not a class or namespace",
11261 TREE_OPERAND (member
, 0));
11263 return error_mark_node
;
11265 else if (TREE_CODE (member
) == FIELD_DECL
)
11266 return finish_non_static_data_member (member
, object
, NULL_TREE
);
11268 return finish_class_member_access_expr (object
, member
,
11269 /*template_p=*/false);
11274 (RECUR (TREE_OPERAND (t
, 0)));
11278 VEC(constructor_elt
,gc
) *n
;
11279 constructor_elt
*ce
;
11280 unsigned HOST_WIDE_INT idx
;
11281 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11282 bool process_index_p
;
11284 bool need_copy_p
= false;
11286 if (type
== error_mark_node
)
11287 return error_mark_node
;
11289 /* digest_init will do the wrong thing if we let it. */
11290 if (type
&& TYPE_PTRMEMFUNC_P (type
))
11293 /* We do not want to process the index of aggregate
11294 initializers as they are identifier nodes which will be
11295 looked up by digest_init. */
11296 process_index_p
= !(type
&& IS_AGGR_TYPE (type
));
11298 n
= VEC_copy (constructor_elt
, gc
, CONSTRUCTOR_ELTS (t
));
11299 newlen
= VEC_length (constructor_elt
, n
);
11300 for (idx
= 0; VEC_iterate (constructor_elt
, n
, idx
, ce
); idx
++)
11302 if (ce
->index
&& process_index_p
)
11303 ce
->index
= RECUR (ce
->index
);
11305 if (PACK_EXPANSION_P (ce
->value
))
11307 /* Substitute into the pack expansion. */
11308 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
11311 if (ce
->value
== error_mark_node
)
11313 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
11314 /* Just move the argument into place. */
11315 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
11318 /* Update the length of the final CONSTRUCTOR
11319 arguments vector, and note that we will need to
11321 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
11322 need_copy_p
= true;
11326 ce
->value
= RECUR (ce
->value
);
11331 VEC(constructor_elt
,gc
) *old_n
= n
;
11333 n
= VEC_alloc (constructor_elt
, gc
, newlen
);
11334 for (idx
= 0; VEC_iterate (constructor_elt
, old_n
, idx
, ce
);
11337 if (TREE_CODE (ce
->value
) == TREE_VEC
)
11339 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
11340 for (i
= 0; i
< len
; ++i
)
11341 CONSTRUCTOR_APPEND_ELT (n
, 0,
11342 TREE_VEC_ELT (ce
->value
, i
));
11345 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
11349 if (TREE_HAS_CONSTRUCTOR (t
))
11350 return finish_compound_literal (type
, n
);
11352 return build_constructor (NULL_TREE
, n
);
11357 tree operand_0
= RECUR (TREE_OPERAND (t
, 0));
11358 if (TYPE_P (operand_0
))
11359 return get_typeid (operand_0
);
11360 return build_typeid (operand_0
);
11370 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
11372 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
11373 /* If the original type was a reference, we'll be wrapped in
11374 the appropriate INDIRECT_REF. */
11375 r
= convert_from_reference (r
);
11380 return build_x_va_arg (RECUR (TREE_OPERAND (t
, 0)),
11381 tsubst_copy (TREE_TYPE (t
), args
, complain
,
11384 case OFFSETOF_EXPR
:
11385 return finish_offsetof (RECUR (TREE_OPERAND (t
, 0)));
11389 tree type1
= tsubst_copy (TRAIT_EXPR_TYPE1 (t
), args
,
11390 complain
, in_decl
);
11392 tree type2
= TRAIT_EXPR_TYPE2 (t
);
11394 type2
= tsubst_copy (type2
, args
, complain
, in_decl
);
11396 return finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
);
11401 tree old_stmt_expr
= cur_stmt_expr
;
11402 tree stmt_expr
= begin_stmt_expr ();
11404 cur_stmt_expr
= stmt_expr
;
11405 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
11406 integral_constant_expression_p
);
11407 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
11408 cur_stmt_expr
= old_stmt_expr
;
11414 t
= tsubst_copy (t
, args
, complain
, in_decl
);
11415 /* As in finish_id_expression, we resolve enumeration constants
11416 to their underlying values. */
11417 if (TREE_CODE (t
) == CONST_DECL
)
11419 used_types_insert (TREE_TYPE (t
));
11420 return DECL_INITIAL (t
);
11425 /* Handle Objective-C++ constructs, if appropriate. */
11428 = objcp_tsubst_copy_and_build (t
, args
, complain
,
11429 in_decl
, /*function_p=*/false);
11433 return tsubst_copy (t
, args
, complain
, in_decl
);
11439 /* Verify that the instantiated ARGS are valid. For type arguments,
11440 make sure that the type's linkage is ok. For non-type arguments,
11441 make sure they are constants if they are integral or enumerations.
11442 Emit an error under control of COMPLAIN, and return TRUE on error. */
11445 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
11447 int ix
, len
= DECL_NTPARMS (tmpl
);
11448 bool result
= false;
11450 for (ix
= 0; ix
!= len
; ix
++)
11452 tree t
= TREE_VEC_ELT (args
, ix
);
11456 /* [basic.link]: A name with no linkage (notably, the name
11457 of a class or enumeration declared in a local scope)
11458 shall not be used to declare an entity with linkage.
11459 This implies that names with no linkage cannot be used as
11460 template arguments. */
11461 tree nt
= no_linkage_check (t
, /*relaxed_p=*/false);
11465 /* DR 488 makes use of a type with no linkage cause
11466 type deduction to fail. */
11467 if (complain
& tf_error
)
11469 if (TYPE_ANONYMOUS_P (nt
))
11470 error ("%qT is/uses anonymous type", t
);
11472 error ("template argument for %qD uses local type %qT",
11477 /* In order to avoid all sorts of complications, we do not
11478 allow variably-modified types as template arguments. */
11479 else if (variably_modified_type_p (t
, NULL_TREE
))
11481 if (complain
& tf_error
)
11482 error ("%qT is a variably modified type", t
);
11486 /* A non-type argument of integral or enumerated type must be a
11488 else if (TREE_TYPE (t
)
11489 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
11490 && !TREE_CONSTANT (t
))
11492 if (complain
& tf_error
)
11493 error ("integral expression %qE is not constant", t
);
11497 if (result
&& (complain
& tf_error
))
11498 error (" trying to instantiate %qD", tmpl
);
11502 /* Instantiate the indicated variable or function template TMPL with
11503 the template arguments in TARG_PTR. */
11506 instantiate_template (tree tmpl
, tree targ_ptr
, tsubst_flags_t complain
)
11511 HOST_WIDE_INT saved_processing_template_decl
;
11513 if (tmpl
== error_mark_node
)
11514 return error_mark_node
;
11516 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
11518 /* If this function is a clone, handle it specially. */
11519 if (DECL_CLONED_FUNCTION_P (tmpl
))
11524 spec
= instantiate_template (DECL_CLONED_FUNCTION (tmpl
), targ_ptr
,
11526 if (spec
== error_mark_node
)
11527 return error_mark_node
;
11529 /* Look for the clone. */
11530 FOR_EACH_CLONE (clone
, spec
)
11531 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
11533 /* We should always have found the clone by now. */
11534 gcc_unreachable ();
11538 /* Check to see if we already have this specialization. */
11539 spec
= retrieve_specialization (tmpl
, targ_ptr
,
11540 /*class_specializations_p=*/false);
11541 if (spec
!= NULL_TREE
)
11544 gen_tmpl
= most_general_template (tmpl
);
11545 if (tmpl
!= gen_tmpl
)
11547 /* The TMPL is a partial instantiation. To get a full set of
11548 arguments we must add the arguments used to perform the
11549 partial instantiation. */
11550 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
11553 /* Check to see if we already have this specialization. */
11554 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
,
11555 /*class_specializations_p=*/false);
11556 if (spec
!= NULL_TREE
)
11560 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
11562 return error_mark_node
;
11564 /* We are building a FUNCTION_DECL, during which the access of its
11565 parameters and return types have to be checked. However this
11566 FUNCTION_DECL which is the desired context for access checking
11567 is not built yet. We solve this chicken-and-egg problem by
11568 deferring all checks until we have the FUNCTION_DECL. */
11569 push_deferring_access_checks (dk_deferred
);
11571 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11572 (because, for example, we have encountered a non-dependent
11573 function call in the body of a template function and must now
11574 determine which of several overloaded functions will be called),
11575 within the instantiation itself we are not processing a
11577 saved_processing_template_decl
= processing_template_decl
;
11578 processing_template_decl
= 0;
11579 /* Substitute template parameters to obtain the specialization. */
11580 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
11581 targ_ptr
, complain
, gen_tmpl
);
11582 processing_template_decl
= saved_processing_template_decl
;
11583 if (fndecl
== error_mark_node
)
11584 return error_mark_node
;
11586 /* Now we know the specialization, compute access previously
11588 push_access_scope (fndecl
);
11589 perform_deferred_access_checks ();
11590 pop_access_scope (fndecl
);
11591 pop_deferring_access_checks ();
11593 /* The DECL_TI_TEMPLATE should always be the immediate parent
11594 template, not the most general template. */
11595 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
11597 /* If we've just instantiated the main entry point for a function,
11598 instantiate all the alternate entry points as well. We do this
11599 by cloning the instantiation of the main entry point, not by
11600 instantiating the template clones. */
11601 if (TREE_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl
)))
11602 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
11607 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11608 arguments that are being used when calling it. TARGS is a vector
11609 into which the deduced template arguments are placed.
11611 Return zero for success, 2 for an incomplete match that doesn't resolve
11612 all the types, and 1 for complete failure. An error message will be
11613 printed only for an incomplete match.
11615 If FN is a conversion operator, or we are trying to produce a specific
11616 specialization, RETURN_TYPE is the return type desired.
11618 The EXPLICIT_TARGS are explicit template arguments provided via a
11621 The parameter STRICT is one of:
11624 We are deducing arguments for a function call, as in
11625 [temp.deduct.call].
11628 We are deducing arguments for a conversion function, as in
11629 [temp.deduct.conv].
11632 We are deducing arguments when doing an explicit instantiation
11633 as in [temp.explicit], when determining an explicit specialization
11634 as in [temp.expl.spec], or when taking the address of a function
11635 template, as in [temp.deduct.funcaddr]. */
11638 fn_type_unification (tree fn
,
11639 tree explicit_targs
,
11643 unification_kind_t strict
,
11649 bool incomplete_argument_packs_p
= false;
11651 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
11653 fntype
= TREE_TYPE (fn
);
11654 if (explicit_targs
)
11658 The specified template arguments must match the template
11659 parameters in kind (i.e., type, nontype, template), and there
11660 must not be more arguments than there are parameters;
11661 otherwise type deduction fails.
11663 Nontype arguments must match the types of the corresponding
11664 nontype template parameters, or must be convertible to the
11665 types of the corresponding nontype parameters as specified in
11666 _temp.arg.nontype_, otherwise type deduction fails.
11668 All references in the function type of the function template
11669 to the corresponding template parameters are replaced by the
11670 specified template argument values. If a substitution in a
11671 template parameter or in the function type of the function
11672 template results in an invalid type, type deduction fails. */
11673 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
11674 int i
, len
= TREE_VEC_LENGTH (tparms
);
11675 tree converted_args
;
11676 bool incomplete
= false;
11678 if (explicit_targs
== error_mark_node
)
11682 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
, tf_none
,
11683 /*require_all_args=*/false,
11684 /*use_default_args=*/false));
11685 if (converted_args
== error_mark_node
)
11688 /* Substitute the explicit args into the function type. This is
11689 necessary so that, for instance, explicitly declared function
11690 arguments can match null pointed constants. If we were given
11691 an incomplete set of explicit args, we must not do semantic
11692 processing during substitution as we could create partial
11694 for (i
= 0; i
< len
; i
++)
11696 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
11697 bool parameter_pack
= false;
11699 /* Dig out the actual parm. */
11700 if (TREE_CODE (parm
) == TYPE_DECL
11701 || TREE_CODE (parm
) == TEMPLATE_DECL
)
11703 parm
= TREE_TYPE (parm
);
11704 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
11706 else if (TREE_CODE (parm
) == PARM_DECL
)
11708 parm
= DECL_INITIAL (parm
);
11709 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
11712 if (parameter_pack
)
11716 template_parm_level_and_index (parm
, &level
, &idx
);
11718 /* Mark the argument pack as "incomplete". We could
11719 still deduce more arguments during unification. */
11720 targ
= TMPL_ARG (converted_args
, level
, idx
);
11723 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
11724 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
11725 = ARGUMENT_PACK_ARGS (targ
);
11728 /* We have some incomplete argument packs. */
11729 incomplete_argument_packs_p
= true;
11733 if (incomplete_argument_packs_p
)
11734 /* Any substitution is guaranteed to be incomplete if there
11735 are incomplete argument packs, because we can still deduce
11739 incomplete
= NUM_TMPL_ARGS (explicit_targs
) != NUM_TMPL_ARGS (targs
);
11741 processing_template_decl
+= incomplete
;
11742 fntype
= tsubst (fntype
, converted_args
, tf_none
, NULL_TREE
);
11743 processing_template_decl
-= incomplete
;
11745 if (fntype
== error_mark_node
)
11748 /* Place the explicitly specified arguments in TARGS. */
11749 for (i
= NUM_TMPL_ARGS (converted_args
); i
--;)
11750 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (converted_args
, i
);
11753 /* Never do unification on the 'this' parameter. */
11754 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
11758 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
11759 args
= tree_cons (NULL_TREE
, return_type
, args
);
11762 /* We allow incomplete unification without an error message here
11763 because the standard doesn't seem to explicitly prohibit it. Our
11764 callers must be ready to deal with unification failures in any
11766 result
= type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
11767 targs
, parms
, args
, /*subr=*/0,
11770 if (result
== 0 && incomplete_argument_packs_p
)
11772 int i
, len
= NUM_TMPL_ARGS (targs
);
11774 /* Clear the "incomplete" flags on all argument packs. */
11775 for (i
= 0; i
< len
; i
++)
11777 tree arg
= TREE_VEC_ELT (targs
, i
);
11778 if (ARGUMENT_PACK_P (arg
))
11780 ARGUMENT_PACK_INCOMPLETE_P (arg
) = 0;
11781 ARGUMENT_PACK_EXPLICIT_ARGS (arg
) = NULL_TREE
;
11786 /* Now that we have bindings for all of the template arguments,
11787 ensure that the arguments deduced for the template template
11788 parameters have compatible template parameter lists. We cannot
11789 check this property before we have deduced all template
11790 arguments, because the template parameter types of a template
11791 template parameter might depend on prior template parameters
11792 deduced after the template template parameter. The following
11793 ill-formed example illustrates this issue:
11795 template<typename T, template<T> class C> void f(C<5>, T);
11797 template<int N> struct X {};
11800 f(X<5>(), 5l); // error: template argument deduction fails
11803 The template parameter list of 'C' depends on the template type
11804 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
11805 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
11806 time that we deduce 'C'. */
11808 && !template_template_parm_bindings_ok_p
11809 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
11813 /* All is well so far. Now, check:
11817 When all template arguments have been deduced, all uses of
11818 template parameters in nondeduced contexts are replaced with
11819 the corresponding deduced argument values. If the
11820 substitution results in an invalid type, as described above,
11821 type deduction fails. */
11823 tree substed
= tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
);
11824 if (substed
== error_mark_node
)
11827 /* If we're looking for an exact match, check that what we got
11828 is indeed an exact match. It might not be if some template
11829 parameters are used in non-deduced contexts. */
11830 if (strict
== DEDUCE_EXACT
)
11833 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (substed
));
11836 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
11837 for (; arg
&& sarg
;
11838 arg
= TREE_CHAIN (arg
), sarg
= TREE_CHAIN (sarg
))
11839 if (!same_type_p (TREE_VALUE (arg
), TREE_VALUE (sarg
)))
11847 /* Adjust types before performing type deduction, as described in
11848 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11849 sections are symmetric. PARM is the type of a function parameter
11850 or the return type of the conversion function. ARG is the type of
11851 the argument passed to the call, or the type of the value
11852 initialized with the result of the conversion function.
11853 ARG_EXPR is the original argument expression, which may be null. */
11856 maybe_adjust_types_for_deduction (unification_kind_t strict
,
11870 /* Swap PARM and ARG throughout the remainder of this
11871 function; the handling is precisely symmetric since PARM
11872 will initialize ARG rather than vice versa. */
11880 /* There is nothing to do in this case. */
11884 gcc_unreachable ();
11887 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
11889 /* [temp.deduct.call]
11891 If P is not a reference type:
11893 --If A is an array type, the pointer type produced by the
11894 array-to-pointer standard conversion (_conv.array_) is
11895 used in place of A for type deduction; otherwise,
11897 --If A is a function type, the pointer type produced by
11898 the function-to-pointer standard conversion
11899 (_conv.func_) is used in place of A for type deduction;
11902 --If A is a cv-qualified type, the top level
11903 cv-qualifiers of A's type are ignored for type
11905 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
11906 *arg
= build_pointer_type (TREE_TYPE (*arg
));
11907 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
11908 *arg
= build_pointer_type (*arg
);
11910 *arg
= TYPE_MAIN_VARIANT (*arg
);
11913 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11914 of the form T&&, where T is a template parameter, and the argument
11915 is an lvalue, T is deduced as A& */
11916 if (TREE_CODE (*parm
) == REFERENCE_TYPE
11917 && TYPE_REF_IS_RVALUE (*parm
)
11918 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
11919 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
11920 && arg_expr
&& real_lvalue_p (arg_expr
))
11921 *arg
= build_reference_type (*arg
);
11923 /* [temp.deduct.call]
11925 If P is a cv-qualified type, the top level cv-qualifiers
11926 of P's type are ignored for type deduction. If P is a
11927 reference type, the type referred to by P is used for
11929 *parm
= TYPE_MAIN_VARIANT (*parm
);
11930 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
11932 *parm
= TREE_TYPE (*parm
);
11933 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
11936 /* DR 322. For conversion deduction, remove a reference type on parm
11937 too (which has been swapped into ARG). */
11938 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
11939 *arg
= TREE_TYPE (*arg
);
11944 /* Most parms like fn_type_unification.
11946 If SUBR is 1, we're being called recursively (to unify the
11947 arguments of a function or method parameter of a function
11951 type_unification_real (tree tparms
,
11956 unification_kind_t strict
,
11959 tree parm
, arg
, arg_expr
;
11961 int ntparms
= TREE_VEC_LENGTH (tparms
);
11963 int saw_undeduced
= 0;
11966 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
11967 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
11968 gcc_assert (!xargs
|| TREE_CODE (xargs
) == TREE_LIST
);
11969 gcc_assert (ntparms
> 0);
11974 sub_strict
= (UNIFY_ALLOW_OUTER_LEVEL
| UNIFY_ALLOW_MORE_CV_QUAL
11975 | UNIFY_ALLOW_DERIVED
);
11979 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
11983 sub_strict
= UNIFY_ALLOW_NONE
;
11987 gcc_unreachable ();
11994 while (parms
&& parms
!= void_list_node
11995 && args
&& args
!= void_list_node
)
11997 if (TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
12000 parm
= TREE_VALUE (parms
);
12001 parms
= TREE_CHAIN (parms
);
12002 arg
= TREE_VALUE (args
);
12003 args
= TREE_CHAIN (args
);
12006 if (arg
== error_mark_node
)
12008 if (arg
== unknown_type_node
)
12009 /* We can't deduce anything from this, but we might get all the
12010 template args from other function args. */
12013 /* Conversions will be performed on a function argument that
12014 corresponds with a function parameter that contains only
12015 non-deducible template parameters and explicitly specified
12016 template parameters. */
12017 if (!uses_template_parms (parm
))
12022 type
= TREE_TYPE (arg
);
12026 if (same_type_p (parm
, type
))
12028 if (strict
!= DEDUCE_EXACT
12029 && can_convert_arg (parm
, type
, TYPE_P (arg
) ? NULL_TREE
: arg
,
12038 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
12039 if (type_unknown_p (arg
))
12041 /* [temp.deduct.type]
12043 A template-argument can be deduced from a pointer to
12044 function or pointer to member function argument if
12045 the set of overloaded functions does not contain
12046 function templates and at most one of a set of
12047 overloaded functions provides a unique match. */
12048 if (resolve_overloaded_unification
12049 (tparms
, targs
, parm
, arg
, strict
, sub_strict
))
12055 arg
= unlowered_expr_type (arg
);
12056 if (arg
== error_mark_node
)
12061 int arg_strict
= sub_strict
;
12064 arg_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
,
12067 if (unify (tparms
, targs
, parm
, arg
, arg_strict
))
12074 && parms
!= void_list_node
12075 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
12077 /* Unify the remaining arguments with the pack expansion type. */
12079 tree parmvec
= make_tree_vec (1);
12083 /* Count the number of arguments that remain. */
12084 for (t
= args
; t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
12087 /* Allocate a TREE_VEC and copy in all of the arguments */
12088 argvec
= make_tree_vec (len
);
12089 for (i
= 0; args
&& args
!= void_list_node
; args
= TREE_CHAIN (args
))
12091 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (args
);
12095 /* Copy the parameter into parmvec. */
12096 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
12097 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
12098 /*call_args_p=*/true, /*subr=*/subr
))
12101 /* Advance to the end of the list of parameters. */
12102 parms
= TREE_CHAIN (parms
);
12105 /* Fail if we've reached the end of the parm list, and more args
12106 are present, and the parm list isn't variadic. */
12107 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
12109 /* Fail if parms are left and they don't have default values. */
12110 if (parms
&& parms
!= void_list_node
12111 && TREE_PURPOSE (parms
) == NULL_TREE
)
12115 for (i
= 0; i
< ntparms
; i
++)
12116 if (!TREE_VEC_ELT (targs
, i
))
12120 if (TREE_VEC_ELT (tparms
, i
) == error_mark_node
)
12123 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
12125 /* If this is an undeduced nontype parameter that depends on
12126 a type parameter, try another pass; its type may have been
12127 deduced from a later argument than the one from which
12128 this parameter can be deduced. */
12129 if (TREE_CODE (tparm
) == PARM_DECL
12130 && uses_template_parms (TREE_TYPE (tparm
))
12131 && !saw_undeduced
++)
12134 /* Core issue #226 (C++0x) [temp.deduct]:
12136 If a template argument has not been deduced, its
12137 default template argument, if any, is used.
12139 When we are in C++98 mode, TREE_PURPOSE will either
12140 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12141 to explicitly check cxx_dialect here. */
12142 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
12144 tree arg
= tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)),
12145 targs
, tf_none
, NULL_TREE
);
12146 if (arg
== error_mark_node
)
12150 TREE_VEC_ELT (targs
, i
) = arg
;
12155 /* If the type parameter is a parameter pack, then it will
12156 be deduced to an empty parameter pack. */
12157 if (template_parameter_pack_p (tparm
))
12161 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
12163 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
12164 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
12165 TREE_CONSTANT (arg
) = 1;
12168 arg
= make_node (TYPE_ARGUMENT_PACK
);
12170 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
12172 TREE_VEC_ELT (targs
, i
) = arg
;
12182 /* Subroutine of type_unification_real. Args are like the variables
12183 at the call site. ARG is an overloaded function (or template-id);
12184 we try deducing template args from each of the overloads, and if
12185 only one succeeds, we go with that. Modifies TARGS and returns
12186 true on success. */
12189 resolve_overloaded_unification (tree tparms
,
12193 unification_kind_t strict
,
12196 tree tempargs
= copy_node (targs
);
12200 if (TREE_CODE (arg
) == ADDR_EXPR
)
12202 arg
= TREE_OPERAND (arg
, 0);
12208 if (TREE_CODE (arg
) == COMPONENT_REF
)
12209 /* Handle `&x' where `x' is some static or non-static member
12211 arg
= TREE_OPERAND (arg
, 1);
12213 if (TREE_CODE (arg
) == OFFSET_REF
)
12214 arg
= TREE_OPERAND (arg
, 1);
12216 /* Strip baselink information. */
12217 if (BASELINK_P (arg
))
12218 arg
= BASELINK_FUNCTIONS (arg
);
12220 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
12222 /* If we got some explicit template args, we need to plug them into
12223 the affected templates before we try to unify, in case the
12224 explicit args will completely resolve the templates in question. */
12226 tree expl_subargs
= TREE_OPERAND (arg
, 1);
12227 arg
= TREE_OPERAND (arg
, 0);
12229 for (; arg
; arg
= OVL_NEXT (arg
))
12231 tree fn
= OVL_CURRENT (arg
);
12232 tree subargs
, elem
;
12234 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
12237 ++processing_template_decl
;
12238 subargs
= get_bindings (fn
, DECL_TEMPLATE_RESULT (fn
),
12239 expl_subargs
, /*check_ret=*/false);
12242 elem
= tsubst (TREE_TYPE (fn
), subargs
, tf_none
, NULL_TREE
);
12243 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
12244 elem
, strict
, sub_strict
, addr_p
);
12246 --processing_template_decl
;
12249 else if (TREE_CODE (arg
) != OVERLOAD
12250 && TREE_CODE (arg
) != FUNCTION_DECL
)
12251 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12252 -- but the deduction does not succeed because the expression is
12253 not just the function on its own. */
12256 for (; arg
; arg
= OVL_NEXT (arg
))
12257 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
12258 TREE_TYPE (OVL_CURRENT (arg
)),
12259 strict
, sub_strict
, addr_p
);
12261 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12262 to function or pointer to member function argument if the set of
12263 overloaded functions does not contain function templates and at most
12264 one of a set of overloaded functions provides a unique match.
12266 So if we found multiple possibilities, we return success but don't
12267 deduce anything. */
12271 int i
= TREE_VEC_LENGTH (targs
);
12273 if (TREE_VEC_ELT (tempargs
, i
))
12274 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
12282 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12283 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12284 different overloads deduce different arguments for a given parm.
12285 ADDR_P is true if the expression for which deduction is being
12286 performed was of the form "& fn" rather than simply "fn".
12288 Returns 1 on success. */
12291 try_one_overload (tree tparms
,
12296 unification_kind_t strict
,
12304 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12305 to function or pointer to member function argument if the set of
12306 overloaded functions does not contain function templates and at most
12307 one of a set of overloaded functions provides a unique match.
12309 So if this is a template, just return success. */
12311 if (uses_template_parms (arg
))
12314 if (TREE_CODE (arg
) == METHOD_TYPE
)
12315 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
12317 arg
= build_pointer_type (arg
);
12319 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
12321 /* We don't copy orig_targs for this because if we have already deduced
12322 some template args from previous args, unify would complain when we
12323 try to deduce a template parameter for the same argument, even though
12324 there isn't really a conflict. */
12325 nargs
= TREE_VEC_LENGTH (targs
);
12326 tempargs
= make_tree_vec (nargs
);
12328 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
) != 0)
12331 /* First make sure we didn't deduce anything that conflicts with
12332 explicitly specified args. */
12333 for (i
= nargs
; i
--; )
12335 tree elt
= TREE_VEC_ELT (tempargs
, i
);
12336 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
12340 else if (uses_template_parms (elt
))
12341 /* Since we're unifying against ourselves, we will fill in
12342 template args used in the function parm list with our own
12343 template parms. Discard them. */
12344 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
12345 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
12349 for (i
= nargs
; i
--; )
12351 tree elt
= TREE_VEC_ELT (tempargs
, i
);
12354 TREE_VEC_ELT (targs
, i
) = elt
;
12360 /* PARM is a template class (perhaps with unbound template
12361 parameters). ARG is a fully instantiated type. If ARG can be
12362 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12363 TARGS are as for unify. */
12366 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
)
12368 tree copy_of_targs
;
12370 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
12371 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
12372 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
12375 /* We need to make a new template argument vector for the call to
12376 unify. If we used TARGS, we'd clutter it up with the result of
12377 the attempted unification, even if this class didn't work out.
12378 We also don't want to commit ourselves to all the unifications
12379 we've already done, since unification is supposed to be done on
12380 an argument-by-argument basis. In other words, consider the
12381 following pathological case:
12383 template <int I, int J, int K>
12386 template <int I, int J>
12387 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12389 template <int I, int J, int K>
12390 void f(S<I, J, K>, S<I, I, I>);
12399 Now, by the time we consider the unification involving `s2', we
12400 already know that we must have `f<0, 0, 0>'. But, even though
12401 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12402 because there are two ways to unify base classes of S<0, 1, 2>
12403 with S<I, I, I>. If we kept the already deduced knowledge, we
12404 would reject the possibility I=1. */
12405 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
12407 /* If unification failed, we're done. */
12408 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
12409 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
))
12415 /* Given a template type PARM and a class type ARG, find the unique
12416 base type in ARG that is an instance of PARM. We do not examine
12417 ARG itself; only its base-classes. If there is not exactly one
12418 appropriate base class, return NULL_TREE. PARM may be the type of
12419 a partial specialization, as well as a plain template type. Used
12423 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
)
12425 tree rval
= NULL_TREE
;
12428 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg
)));
12430 binfo
= TYPE_BINFO (complete_type (arg
));
12432 /* The type could not be completed. */
12435 /* Walk in inheritance graph order. The search order is not
12436 important, and this avoids multiple walks of virtual bases. */
12437 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
12439 tree r
= try_class_unification (tparms
, targs
, parm
, BINFO_TYPE (binfo
));
12443 /* If there is more than one satisfactory baseclass, then:
12447 If they yield more than one possible deduced A, the type
12451 if (rval
&& !same_type_p (r
, rval
))
12461 /* Returns the level of DECL, which declares a template parameter. */
12464 template_decl_level (tree decl
)
12466 switch (TREE_CODE (decl
))
12469 case TEMPLATE_DECL
:
12470 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
12473 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
12476 gcc_unreachable ();
12481 /* Decide whether ARG can be unified with PARM, considering only the
12482 cv-qualifiers of each type, given STRICT as documented for unify.
12483 Returns nonzero iff the unification is OK on that basis. */
12486 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
12488 int arg_quals
= cp_type_quals (arg
);
12489 int parm_quals
= cp_type_quals (parm
);
12491 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
12492 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
12494 /* Although a CVR qualifier is ignored when being applied to a
12495 substituted template parameter ([8.3.2]/1 for example), that
12496 does not apply during deduction [14.8.2.4]/1, (even though
12497 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12498 this). Except when we're allowing additional CV qualifiers
12499 at the outer level [14.8.2.1]/3,1st bullet. */
12500 if ((TREE_CODE (arg
) == REFERENCE_TYPE
12501 || TREE_CODE (arg
) == FUNCTION_TYPE
12502 || TREE_CODE (arg
) == METHOD_TYPE
)
12503 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
12506 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
12507 && (parm_quals
& TYPE_QUAL_RESTRICT
))
12511 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
12512 && (arg_quals
& parm_quals
) != parm_quals
)
12515 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
12516 && (parm_quals
& arg_quals
) != arg_quals
)
12522 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12524 template_parm_level_and_index (tree parm
, int* level
, int* index
)
12526 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
12527 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
12528 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12530 *index
= TEMPLATE_TYPE_IDX (parm
);
12531 *level
= TEMPLATE_TYPE_LEVEL (parm
);
12535 *index
= TEMPLATE_PARM_IDX (parm
);
12536 *level
= TEMPLATE_PARM_LEVEL (parm
);
12540 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12541 expansion at the end of PACKED_PARMS. Returns 0 if the type
12542 deduction succeeds, 1 otherwise. STRICT is the same as in
12543 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12544 call argument list. We'll need to adjust the arguments to make them
12545 types. SUBR tells us if this is from a recursive call to
12546 type_unification_real. */
12548 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
12549 tree packed_args
, int strict
, bool call_args_p
,
12553 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
12554 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
12555 tree pack
, packs
= NULL_TREE
;
12556 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
12557 int len
= TREE_VEC_LENGTH (packed_args
);
12559 /* Determine the parameter packs we will be deducing from the
12560 pattern, and record their current deductions. */
12561 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
12562 pack
; pack
= TREE_CHAIN (pack
))
12564 tree parm_pack
= TREE_VALUE (pack
);
12567 /* Determine the index and level of this parameter pack. */
12568 template_parm_level_and_index (parm_pack
, &level
, &idx
);
12570 /* Keep track of the parameter packs and their corresponding
12572 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
12573 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
12576 /* Loop through all of the arguments that have not yet been
12577 unified and unify each with the pattern. */
12578 for (i
= start
; i
< len
; i
++)
12580 tree parm
= pattern
;
12582 /* For each parameter pack, clear out the deduced value so that
12583 we can deduce it again. */
12584 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12587 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12589 TMPL_ARG (targs
, level
, idx
) = NULL_TREE
;
12592 /* Unify the pattern with the current argument. */
12594 tree arg
= TREE_VEC_ELT (packed_args
, i
);
12595 tree arg_expr
= NULL_TREE
;
12596 int arg_strict
= strict
;
12597 bool skip_arg_p
= false;
12603 /* This mirrors what we do in type_unification_real. */
12607 sub_strict
= (UNIFY_ALLOW_OUTER_LEVEL
12608 | UNIFY_ALLOW_MORE_CV_QUAL
12609 | UNIFY_ALLOW_DERIVED
);
12613 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
12617 sub_strict
= UNIFY_ALLOW_NONE
;
12621 gcc_unreachable ();
12626 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
12627 if (type_unknown_p (arg
))
12629 /* [temp.deduct.type] A template-argument can be
12630 deduced from a pointer to function or pointer
12631 to member function argument if the set of
12632 overloaded functions does not contain function
12633 templates and at most one of a set of
12634 overloaded functions provides a unique
12637 if (resolve_overloaded_unification
12638 (tparms
, targs
, parm
, arg
, strict
, sub_strict
)
12647 arg
= unlowered_expr_type (arg
);
12648 if (arg
== error_mark_node
)
12653 arg_strict
= sub_strict
;
12657 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
,
12663 if (unify (tparms
, targs
, parm
, arg
, arg_strict
))
12668 /* For each parameter pack, collect the deduced value. */
12669 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12672 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12674 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
12675 TMPL_ARG (targs
, level
, idx
);
12679 /* Verify that the results of unification with the parameter packs
12680 produce results consistent with what we've seen before, and make
12681 the deduced argument packs available. */
12682 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12684 tree old_pack
= TREE_VALUE (pack
);
12685 tree new_args
= TREE_TYPE (pack
);
12686 int i
, len
= TREE_VEC_LENGTH (new_args
);
12687 bool nondeduced_p
= false;
12689 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
12690 actually deduce anything. */
12691 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
12692 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
12693 nondeduced_p
= true;
12697 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
12699 /* Prepend the explicit arguments onto NEW_ARGS. */
12700 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
12701 tree old_args
= new_args
;
12702 int i
, explicit_len
= TREE_VEC_LENGTH (explicit_args
);
12703 int len
= explicit_len
+ TREE_VEC_LENGTH (old_args
);
12705 /* Copy the explicit arguments. */
12706 new_args
= make_tree_vec (len
);
12707 for (i
= 0; i
< explicit_len
; i
++)
12708 TREE_VEC_ELT (new_args
, i
) = TREE_VEC_ELT (explicit_args
, i
);
12710 /* Copy the deduced arguments. */
12711 for (; i
< len
; i
++)
12712 TREE_VEC_ELT (new_args
, i
) =
12713 TREE_VEC_ELT (old_args
, i
- explicit_len
);
12721 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12723 /* Build the deduced *_ARGUMENT_PACK. */
12724 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
12726 result
= make_node (NONTYPE_ARGUMENT_PACK
);
12727 TREE_TYPE (result
) =
12728 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
12729 TREE_CONSTANT (result
) = 1;
12732 result
= make_node (TYPE_ARGUMENT_PACK
);
12734 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
12736 /* Note the deduced argument packs for this parameter
12738 TMPL_ARG (targs
, level
, idx
) = result
;
12740 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
12741 && (ARGUMENT_PACK_ARGS (old_pack
)
12742 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
12744 /* We only had the explicitly-provided arguments before, but
12745 now we have a complete set of arguments. */
12747 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
12748 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12750 /* Keep the original deduced argument pack. */
12751 TMPL_ARG (targs
, level
, idx
) = old_pack
;
12753 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
12754 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
12755 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
12757 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack
),
12759 /* Inconsistent unification of this parameter pack. */
12765 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12767 /* Keep the original deduced argument pack. */
12768 TMPL_ARG (targs
, level
, idx
) = old_pack
;
12775 /* Deduce the value of template parameters. TPARMS is the (innermost)
12776 set of template parameters to a template. TARGS is the bindings
12777 for those template parameters, as determined thus far; TARGS may
12778 include template arguments for outer levels of template parameters
12779 as well. PARM is a parameter to a template function, or a
12780 subcomponent of that parameter; ARG is the corresponding argument.
12781 This function attempts to match PARM with ARG in a manner
12782 consistent with the existing assignments in TARGS. If more values
12783 are deduced, then TARGS is updated.
12785 Returns 0 if the type deduction succeeds, 1 otherwise. The
12786 parameter STRICT is a bitwise or of the following flags:
12789 Require an exact match between PARM and ARG.
12790 UNIFY_ALLOW_MORE_CV_QUAL:
12791 Allow the deduced ARG to be more cv-qualified (by qualification
12792 conversion) than ARG.
12793 UNIFY_ALLOW_LESS_CV_QUAL:
12794 Allow the deduced ARG to be less cv-qualified than ARG.
12795 UNIFY_ALLOW_DERIVED:
12796 Allow the deduced ARG to be a template base class of ARG,
12797 or a pointer to a template base class of the type pointed to by
12799 UNIFY_ALLOW_INTEGER:
12800 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12801 case for more information.
12802 UNIFY_ALLOW_OUTER_LEVEL:
12803 This is the outermost level of a deduction. Used to determine validity
12804 of qualification conversions. A valid qualification conversion must
12805 have const qualified pointers leading up to the inner type which
12806 requires additional CV quals, except at the outer level, where const
12807 is not required [conv.qual]. It would be normal to set this flag in
12808 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12809 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12810 This is the outermost level of a deduction, and PARM can be more CV
12811 qualified at this point.
12812 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12813 This is the outermost level of a deduction, and PARM can be less CV
12814 qualified at this point. */
12817 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
)
12822 int strict_in
= strict
;
12824 /* I don't think this will do the right thing with respect to types.
12825 But the only case I've seen it in so far has been array bounds, where
12826 signedness is the only information lost, and I think that will be
12828 while (TREE_CODE (parm
) == NOP_EXPR
)
12829 parm
= TREE_OPERAND (parm
, 0);
12831 if (arg
== error_mark_node
)
12833 if (arg
== unknown_type_node
)
12834 /* We can't deduce anything from this, but we might get all the
12835 template args from other function args. */
12838 /* If PARM uses template parameters, then we can't bail out here,
12839 even if ARG == PARM, since we won't record unifications for the
12840 template parameters. We might need them if we're trying to
12841 figure out which of two things is more specialized. */
12842 if (arg
== parm
&& !uses_template_parms (parm
))
12845 /* Immediately reject some pairs that won't unify because of
12846 cv-qualification mismatches. */
12847 if (TREE_CODE (arg
) == TREE_CODE (parm
)
12849 /* It is the elements of the array which hold the cv quals of an array
12850 type, and the elements might be template type parms. We'll check
12851 when we recurse. */
12852 && TREE_CODE (arg
) != ARRAY_TYPE
12853 /* We check the cv-qualifiers when unifying with template type
12854 parameters below. We want to allow ARG `const T' to unify with
12855 PARM `T' for example, when computing which of two templates
12856 is more specialized, for example. */
12857 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
12858 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
12861 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
12862 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
12863 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
12864 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
12865 strict
&= ~UNIFY_ALLOW_DERIVED
;
12866 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
12867 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
12869 switch (TREE_CODE (parm
))
12871 case TYPENAME_TYPE
:
12873 case UNBOUND_CLASS_TEMPLATE
:
12874 /* In a type which contains a nested-name-specifier, template
12875 argument values cannot be deduced for template parameters used
12876 within the nested-name-specifier. */
12879 case TEMPLATE_TYPE_PARM
:
12880 case TEMPLATE_TEMPLATE_PARM
:
12881 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12882 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
12883 if (tparm
== error_mark_node
)
12886 if (TEMPLATE_TYPE_LEVEL (parm
)
12887 != template_decl_level (tparm
))
12888 /* The PARM is not one we're trying to unify. Just check
12889 to see if it matches ARG. */
12890 return (TREE_CODE (arg
) == TREE_CODE (parm
)
12891 && same_type_p (parm
, arg
)) ? 0 : 1;
12892 idx
= TEMPLATE_TYPE_IDX (parm
);
12893 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
12894 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
12896 /* Check for mixed types and values. */
12897 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
12898 && TREE_CODE (tparm
) != TYPE_DECL
)
12899 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
12900 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
12903 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12905 /* ARG must be constructed from a template class or a template
12906 template parameter. */
12907 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
12908 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
12912 tree parmvec
= TYPE_TI_ARGS (parm
);
12913 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
12915 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg
));
12917 int parm_variadic_p
= 0;
12919 /* The resolution to DR150 makes clear that default
12920 arguments for an N-argument may not be used to bind T
12921 to a template template parameter with fewer than N
12922 parameters. It is not safe to permit the binding of
12923 default arguments as an extension, as that may change
12924 the meaning of a conforming program. Consider:
12926 struct Dense { static const unsigned int dim = 1; };
12928 template <template <typename> class View,
12930 void operator+(float, View<Block> const&);
12932 template <typename Block,
12933 unsigned int Dim = Block::dim>
12934 struct Lvalue_proxy { operator float() const; };
12938 Lvalue_proxy<Dense> p;
12943 Here, if Lvalue_proxy is permitted to bind to View, then
12944 the global operator+ will be used; if they are not, the
12945 Lvalue_proxy will be converted to float. */
12946 if (coerce_template_parms (argtmplvec
, parmvec
,
12947 TYPE_TI_TEMPLATE (parm
),
12949 /*require_all_args=*/true,
12950 /*use_default_args=*/false)
12951 == error_mark_node
)
12954 /* Deduce arguments T, i from TT<T> or TT<i>.
12955 We check each element of PARMVEC and ARGVEC individually
12956 rather than the whole TREE_VEC since they can have
12957 different number of elements. */
12959 parmvec
= expand_template_argument_pack (parmvec
);
12960 argvec
= expand_template_argument_pack (argvec
);
12962 len
= TREE_VEC_LENGTH (parmvec
);
12964 /* Check if the parameters end in a pack, making them
12967 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
12968 parm_variadic_p
= 1;
12970 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
12973 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
12975 if (unify (tparms
, targs
,
12976 TREE_VEC_ELT (parmvec
, i
),
12977 TREE_VEC_ELT (argvec
, i
),
12982 if (parm_variadic_p
12983 && unify_pack_expansion (tparms
, targs
,
12986 /*call_args_p=*/false,
12990 arg
= TYPE_TI_TEMPLATE (arg
);
12992 /* Fall through to deduce template name. */
12995 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
12996 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12998 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
13000 /* Simple cases: Value already set, does match or doesn't. */
13001 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
13008 /* If PARM is `const T' and ARG is only `int', we don't have
13009 a match unless we are allowing additional qualification.
13010 If ARG is `const int' and PARM is just `T' that's OK;
13011 that binds `const int' to `T'. */
13012 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
13016 /* Consider the case where ARG is `const volatile int' and
13017 PARM is `const T'. Then, T should be `volatile int'. */
13018 arg
= cp_build_qualified_type_real
13019 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
13020 if (arg
== error_mark_node
)
13023 /* Simple cases: Value already set, does match or doesn't. */
13024 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
13029 /* Make sure that ARG is not a variable-sized array. (Note
13030 that were talking about variable-sized arrays (like
13031 `int[n]'), rather than arrays of unknown size (like
13032 `int[]').) We'll get very confused by such a type since
13033 the bound of the array will not be computable in an
13034 instantiation. Besides, such types are not allowed in
13035 ISO C++, so we can do as we please here. */
13036 if (variably_modified_type_p (arg
, NULL_TREE
))
13040 /* If ARG is a parameter pack or an expansion, we cannot unify
13041 against it unless PARM is also a parameter pack. */
13042 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
13043 && !template_parameter_pack_p (parm
))
13046 /* If the argument deduction results is a METHOD_TYPE,
13047 then there is a problem.
13048 METHOD_TYPE doesn't map to any real C++ type the result of
13049 the deduction can not be of that type. */
13050 if (TREE_CODE (arg
) == METHOD_TYPE
)
13053 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
13056 case TEMPLATE_PARM_INDEX
:
13057 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
13058 if (tparm
== error_mark_node
)
13061 if (TEMPLATE_PARM_LEVEL (parm
)
13062 != template_decl_level (tparm
))
13063 /* The PARM is not one we're trying to unify. Just check
13064 to see if it matches ARG. */
13065 return !(TREE_CODE (arg
) == TREE_CODE (parm
)
13066 && cp_tree_equal (parm
, arg
));
13068 idx
= TEMPLATE_PARM_IDX (parm
);
13069 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
13072 return !cp_tree_equal (targ
, arg
);
13074 /* [temp.deduct.type] If, in the declaration of a function template
13075 with a non-type template-parameter, the non-type
13076 template-parameter is used in an expression in the function
13077 parameter-list and, if the corresponding template-argument is
13078 deduced, the template-argument type shall match the type of the
13079 template-parameter exactly, except that a template-argument
13080 deduced from an array bound may be of any integral type.
13081 The non-type parameter might use already deduced type parameters. */
13082 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
13083 if (!TREE_TYPE (arg
))
13084 /* Template-parameter dependent expression. Just accept it for now.
13085 It will later be processed in convert_template_argument. */
13087 else if (same_type_p (TREE_TYPE (arg
), tparm
))
13089 else if ((strict
& UNIFY_ALLOW_INTEGER
)
13090 && (TREE_CODE (tparm
) == INTEGER_TYPE
13091 || TREE_CODE (tparm
) == BOOLEAN_TYPE
))
13092 /* Convert the ARG to the type of PARM; the deduced non-type
13093 template argument must exactly match the types of the
13094 corresponding parameter. */
13095 arg
= fold (build_nop (tparm
, arg
));
13096 else if (uses_template_parms (tparm
))
13097 /* We haven't deduced the type of this parameter yet. Try again
13103 /* If ARG is a parameter pack or an expansion, we cannot unify
13104 against it unless PARM is also a parameter pack. */
13105 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
13106 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
13109 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
13114 /* A pointer-to-member constant can be unified only with
13115 another constant. */
13116 if (TREE_CODE (arg
) != PTRMEM_CST
)
13119 /* Just unify the class member. It would be useless (and possibly
13120 wrong, depending on the strict flags) to unify also
13121 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13122 arg refer to the same variable, even if through different
13123 classes. For instance:
13125 struct A { int x; };
13128 Unification of &A::x and &B::x must succeed. */
13129 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
13130 PTRMEM_CST_MEMBER (arg
), strict
);
13135 if (TREE_CODE (arg
) != POINTER_TYPE
)
13138 /* [temp.deduct.call]
13140 A can be another pointer or pointer to member type that can
13141 be converted to the deduced A via a qualification
13142 conversion (_conv.qual_).
13144 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
13145 This will allow for additional cv-qualification of the
13146 pointed-to types if appropriate. */
13148 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
13149 /* The derived-to-base conversion only persists through one
13150 level of pointers. */
13151 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
13153 return unify (tparms
, targs
, TREE_TYPE (parm
),
13154 TREE_TYPE (arg
), strict
);
13157 case REFERENCE_TYPE
:
13158 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
13160 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
13161 strict
& UNIFY_ALLOW_MORE_CV_QUAL
);
13164 if (TREE_CODE (arg
) != ARRAY_TYPE
)
13166 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
13167 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
13169 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
13176 /* Our representation of array types uses "N - 1" as the
13177 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
13178 not an integer constant. We cannot unify arbitrarily
13179 complex expressions, so we eliminate the MINUS_EXPRs
13181 parm_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (parm
));
13182 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
13185 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
13186 parm_max
= TREE_OPERAND (parm_max
, 0);
13188 arg_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (arg
));
13189 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
13192 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
13193 trying to unify the type of a variable with the type
13194 of a template parameter. For example:
13196 template <unsigned int N>
13197 void f (char (&) [N]);
13204 Here, the type of the ARG will be "int [g(i)]", and
13205 may be a SAVE_EXPR, etc. */
13206 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
13208 arg_max
= TREE_OPERAND (arg_max
, 0);
13211 /* If only one of the bounds used a MINUS_EXPR, compensate
13212 by adding one to the other bound. */
13213 if (parm_cst
&& !arg_cst
)
13214 parm_max
= fold_build2 (PLUS_EXPR
,
13218 else if (arg_cst
&& !parm_cst
)
13219 arg_max
= fold_build2 (PLUS_EXPR
,
13224 if (unify (tparms
, targs
, parm_max
, arg_max
, UNIFY_ALLOW_INTEGER
))
13227 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
13228 strict
& UNIFY_ALLOW_MORE_CV_QUAL
);
13235 case ENUMERAL_TYPE
:
13237 if (TREE_CODE (arg
) != TREE_CODE (parm
))
13240 /* We have already checked cv-qualification at the top of the
13242 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
13245 /* As far as unification is concerned, this wins. Later checks
13246 will invalidate it if necessary. */
13249 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
13250 /* Type INTEGER_CST can come from ordinary constant template args. */
13252 while (TREE_CODE (arg
) == NOP_EXPR
)
13253 arg
= TREE_OPERAND (arg
, 0);
13255 if (TREE_CODE (arg
) != INTEGER_CST
)
13257 return !tree_int_cst_equal (parm
, arg
);
13262 if (TREE_CODE (arg
) != TREE_VEC
)
13264 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
13266 for (i
= 0; i
< TREE_VEC_LENGTH (parm
); ++i
)
13267 if (unify (tparms
, targs
,
13268 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
13276 if (TREE_CODE (arg
) != TREE_CODE (parm
))
13279 if (TYPE_PTRMEMFUNC_P (parm
))
13281 if (!TYPE_PTRMEMFUNC_P (arg
))
13284 return unify (tparms
, targs
,
13285 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
13286 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
13290 if (CLASSTYPE_TEMPLATE_INFO (parm
))
13292 tree t
= NULL_TREE
;
13294 if (strict_in
& UNIFY_ALLOW_DERIVED
)
13296 /* First, we try to unify the PARM and ARG directly. */
13297 t
= try_class_unification (tparms
, targs
,
13302 /* Fallback to the special case allowed in
13303 [temp.deduct.call]:
13305 If P is a class, and P has the form
13306 template-id, then A can be a derived class of
13307 the deduced A. Likewise, if P is a pointer to
13308 a class of the form template-id, A can be a
13309 pointer to a derived class pointed to by the
13311 t
= get_template_base (tparms
, targs
, parm
, arg
);
13317 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
13318 && (CLASSTYPE_TI_TEMPLATE (parm
)
13319 == CLASSTYPE_TI_TEMPLATE (arg
)))
13320 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13321 Then, we should unify `int' and `U'. */
13324 /* There's no chance of unification succeeding. */
13327 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
13328 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
);
13330 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
13335 case FUNCTION_TYPE
:
13336 if (TREE_CODE (arg
) != TREE_CODE (parm
))
13339 /* CV qualifications for methods can never be deduced, they must
13340 match exactly. We need to check them explicitly here,
13341 because type_unification_real treats them as any other
13342 cvqualified parameter. */
13343 if (TREE_CODE (parm
) == METHOD_TYPE
13344 && (!check_cv_quals_for_unify
13346 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg
))),
13347 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm
))))))
13350 if (unify (tparms
, targs
, TREE_TYPE (parm
),
13351 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
))
13353 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
13354 TYPE_ARG_TYPES (arg
), 1, DEDUCE_EXACT
,
13358 /* Unify a pointer to member with a pointer to member function, which
13359 deduces the type of the member as a function type. */
13360 if (TYPE_PTRMEMFUNC_P (arg
))
13364 cp_cv_quals cv_quals
;
13366 /* Check top-level cv qualifiers */
13367 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
13370 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
13371 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
), UNIFY_ALLOW_NONE
))
13374 /* Determine the type of the function we are unifying against. */
13375 method_type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg
));
13377 build_function_type (TREE_TYPE (method_type
),
13378 TREE_CHAIN (TYPE_ARG_TYPES (method_type
)));
13380 /* Extract the cv-qualifiers of the member function from the
13381 implicit object parameter and place them on the function
13382 type to be restored later. */
13384 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type
))));
13385 fntype
= build_qualified_type (fntype
, cv_quals
);
13386 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
);
13389 if (TREE_CODE (arg
) != OFFSET_TYPE
)
13391 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
13392 TYPE_OFFSET_BASETYPE (arg
), UNIFY_ALLOW_NONE
))
13394 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
13398 if (DECL_TEMPLATE_PARM_P (parm
))
13399 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
);
13400 if (arg
!= integral_constant_value (parm
))
13405 case TEMPLATE_DECL
:
13406 /* Matched cases are handled by the ARG == PARM test above. */
13409 case TYPE_ARGUMENT_PACK
:
13410 case NONTYPE_ARGUMENT_PACK
:
13412 tree packed_parms
= ARGUMENT_PACK_ARGS (parm
);
13413 tree packed_args
= ARGUMENT_PACK_ARGS (arg
);
13414 int i
, len
= TREE_VEC_LENGTH (packed_parms
);
13415 int argslen
= TREE_VEC_LENGTH (packed_args
);
13416 int parm_variadic_p
= 0;
13418 for (i
= 0; i
< len
; ++i
)
13420 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms
, i
)))
13423 /* We can unify against something with a trailing
13425 parm_variadic_p
= 1;
13427 /* Since there is something following the pack
13428 expansion, we cannot unify this template argument
13435 /* If we don't have enough arguments to satisfy the parameters
13436 (not counting the pack expression at the end), or we have
13437 too many arguments for a parameter list that doesn't end in
13438 a pack expression, we can't unify. */
13439 if (argslen
< (len
- parm_variadic_p
)
13440 || (argslen
> len
&& !parm_variadic_p
))
13443 /* Unify all of the parameters that precede the (optional)
13444 pack expression. */
13445 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
13447 if (unify (tparms
, targs
, TREE_VEC_ELT (packed_parms
, i
),
13448 TREE_VEC_ELT (packed_args
, i
), strict
))
13452 if (parm_variadic_p
)
13453 return unify_pack_expansion (tparms
, targs
,
13454 packed_parms
, packed_args
,
13455 strict
, /*call_args_p=*/false,
13463 case DECLTYPE_TYPE
:
13464 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13469 /* Unification fails if we hit an error node. */
13473 gcc_assert (EXPR_P (parm
));
13475 /* We must be looking at an expression. This can happen with
13479 void foo(S<I>, S<I + 2>);
13481 This is a "nondeduced context":
13485 The nondeduced contexts are:
13487 --A type that is a template-id in which one or more of
13488 the template-arguments is an expression that references
13489 a template-parameter.
13491 In these cases, we assume deduction succeeded, but don't
13492 actually infer any unifications. */
13494 if (!uses_template_parms (parm
)
13495 && !template_args_equal (parm
, arg
))
13502 /* Note that DECL can be defined in this translation unit, if
13506 mark_definable (tree decl
)
13509 DECL_NOT_REALLY_EXTERN (decl
) = 1;
13510 FOR_EACH_CLONE (clone
, decl
)
13511 DECL_NOT_REALLY_EXTERN (clone
) = 1;
13514 /* Called if RESULT is explicitly instantiated, or is a member of an
13515 explicitly instantiated class. */
13518 mark_decl_instantiated (tree result
, int extern_p
)
13520 SET_DECL_EXPLICIT_INSTANTIATION (result
);
13522 /* If this entity has already been written out, it's too late to
13523 make any modifications. */
13524 if (TREE_ASM_WRITTEN (result
))
13527 if (TREE_CODE (result
) != FUNCTION_DECL
)
13528 /* The TREE_PUBLIC flag for function declarations will have been
13529 set correctly by tsubst. */
13530 TREE_PUBLIC (result
) = 1;
13532 /* This might have been set by an earlier implicit instantiation. */
13533 DECL_COMDAT (result
) = 0;
13536 DECL_NOT_REALLY_EXTERN (result
) = 0;
13539 mark_definable (result
);
13540 /* Always make artificials weak. */
13541 if (DECL_ARTIFICIAL (result
) && flag_weak
)
13542 comdat_linkage (result
);
13543 /* For WIN32 we also want to put explicit instantiations in
13544 linkonce sections. */
13545 else if (TREE_PUBLIC (result
))
13546 maybe_make_one_only (result
);
13549 /* If EXTERN_P, then this function will not be emitted -- unless
13550 followed by an explicit instantiation, at which point its linkage
13551 will be adjusted. If !EXTERN_P, then this function will be
13552 emitted here. In neither circumstance do we want
13553 import_export_decl to adjust the linkage. */
13554 DECL_INTERFACE_KNOWN (result
) = 1;
13557 /* Given two function templates PAT1 and PAT2, return:
13559 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
13560 -1 if PAT2 is more specialized than PAT1.
13561 0 if neither is more specialized.
13563 LEN indicates the number of parameters we should consider
13564 (defaulted parameters should not be considered).
13566 The 1998 std underspecified function template partial ordering, and
13567 DR214 addresses the issue. We take pairs of arguments, one from
13568 each of the templates, and deduce them against each other. One of
13569 the templates will be more specialized if all the *other*
13570 template's arguments deduce against its arguments and at least one
13571 of its arguments *does* *not* deduce against the other template's
13572 corresponding argument. Deduction is done as for class templates.
13573 The arguments used in deduction have reference and top level cv
13574 qualifiers removed. Iff both arguments were originally reference
13575 types *and* deduction succeeds in both directions, the template
13576 with the more cv-qualified argument wins for that pairing (if
13577 neither is more cv-qualified, they both are equal). Unlike regular
13578 deduction, after all the arguments have been deduced in this way,
13579 we do *not* verify the deduced template argument values can be
13580 substituted into non-deduced contexts, nor do we have to verify
13581 that all template arguments have been deduced. */
13584 more_specialized_fn (tree pat1
, tree pat2
, int len
)
13586 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
13587 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
13588 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
13589 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
13590 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
13591 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
13592 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
13593 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
13597 /* Remove the this parameter from non-static member functions. If
13598 one is a non-static member function and the other is not a static
13599 member function, remove the first parameter from that function
13600 also. This situation occurs for operator functions where we
13601 locate both a member function (with this pointer) and non-member
13602 operator (with explicit first operand). */
13603 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
13605 len
--; /* LEN is the number of significant arguments for DECL1 */
13606 args1
= TREE_CHAIN (args1
);
13607 if (!DECL_STATIC_FUNCTION_P (decl2
))
13608 args2
= TREE_CHAIN (args2
);
13610 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
13612 args2
= TREE_CHAIN (args2
);
13613 if (!DECL_STATIC_FUNCTION_P (decl1
))
13616 args1
= TREE_CHAIN (args1
);
13620 /* If only one is a conversion operator, they are unordered. */
13621 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
13624 /* Consider the return type for a conversion function */
13625 if (DECL_CONV_FN_P (decl1
))
13627 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
13628 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
13632 processing_template_decl
++;
13635 /* Stop when an ellipsis is seen. */
13636 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
13638 tree arg1
= TREE_VALUE (args1
);
13639 tree arg2
= TREE_VALUE (args2
);
13640 int deduce1
, deduce2
;
13644 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
13645 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13647 /* When both arguments are pack expansions, we need only
13648 unify the patterns themselves. */
13649 arg1
= PACK_EXPANSION_PATTERN (arg1
);
13650 arg2
= PACK_EXPANSION_PATTERN (arg2
);
13652 /* This is the last comparison we need to do. */
13656 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
13658 arg1
= TREE_TYPE (arg1
);
13659 quals1
= cp_type_quals (arg1
);
13662 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
13664 arg2
= TREE_TYPE (arg2
);
13665 quals2
= cp_type_quals (arg2
);
13668 if ((quals1
< 0) != (quals2
< 0))
13670 /* Only of the args is a reference, see if we should apply
13671 array/function pointer decay to it. This is not part of
13672 DR214, but is, IMHO, consistent with the deduction rules
13673 for the function call itself, and with our earlier
13674 implementation of the underspecified partial ordering
13675 rules. (nathan). */
13678 switch (TREE_CODE (arg1
))
13681 arg1
= TREE_TYPE (arg1
);
13683 case FUNCTION_TYPE
:
13684 arg1
= build_pointer_type (arg1
);
13693 switch (TREE_CODE (arg2
))
13696 arg2
= TREE_TYPE (arg2
);
13698 case FUNCTION_TYPE
:
13699 arg2
= build_pointer_type (arg2
);
13708 arg1
= TYPE_MAIN_VARIANT (arg1
);
13709 arg2
= TYPE_MAIN_VARIANT (arg2
);
13711 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
13713 int i
, len2
= list_length (args2
);
13714 tree parmvec
= make_tree_vec (1);
13715 tree argvec
= make_tree_vec (len2
);
13718 /* Setup the parameter vector, which contains only ARG1. */
13719 TREE_VEC_ELT (parmvec
, 0) = arg1
;
13721 /* Setup the argument vector, which contains the remaining
13723 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
13724 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
13726 deduce1
= !unify_pack_expansion (tparms1
, targs1
, parmvec
,
13727 argvec
, UNIFY_ALLOW_NONE
,
13728 /*call_args_p=*/false,
13731 /* We cannot deduce in the other direction, because ARG1 is
13732 a pack expansion but ARG2 is not. */
13735 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13737 int i
, len1
= list_length (args1
);
13738 tree parmvec
= make_tree_vec (1);
13739 tree argvec
= make_tree_vec (len1
);
13742 /* Setup the parameter vector, which contains only ARG1. */
13743 TREE_VEC_ELT (parmvec
, 0) = arg2
;
13745 /* Setup the argument vector, which contains the remaining
13747 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
13748 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
13750 deduce2
= !unify_pack_expansion (tparms2
, targs2
, parmvec
,
13751 argvec
, UNIFY_ALLOW_NONE
,
13752 /*call_args_p=*/false,
13755 /* We cannot deduce in the other direction, because ARG2 is
13756 a pack expansion but ARG1 is not.*/
13762 /* The normal case, where neither argument is a pack
13764 deduce1
= !unify (tparms1
, targs1
, arg1
, arg2
, UNIFY_ALLOW_NONE
);
13765 deduce2
= !unify (tparms2
, targs2
, arg2
, arg1
, UNIFY_ALLOW_NONE
);
13772 if (better1
< 0 && better2
< 0)
13773 /* We've failed to deduce something in either direction.
13774 These must be unordered. */
13777 if (deduce1
&& deduce2
&& quals1
>= 0 && quals2
>= 0)
13779 /* Deduces in both directions, see if quals can
13780 disambiguate. Pretend the worse one failed to deduce. */
13781 if ((quals1
& quals2
) == quals2
)
13783 if ((quals1
& quals2
) == quals1
)
13786 if (deduce1
&& !deduce2
&& !better2
)
13788 if (deduce2
&& !deduce1
&& !better1
)
13791 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
13792 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13793 /* We have already processed all of the arguments in our
13794 handing of the pack expansion type. */
13797 args1
= TREE_CHAIN (args1
);
13798 args2
= TREE_CHAIN (args2
);
13801 processing_template_decl
--;
13803 /* All things being equal, if the next argument is a pack expansion
13804 for one function but not for the other, prefer the
13805 non-variadic function. */
13806 if ((better1
> 0) - (better2
> 0) == 0
13807 && args1
&& TREE_VALUE (args1
)
13808 && args2
&& TREE_VALUE (args2
))
13810 if (TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
)
13811 return TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
? 0 : -1;
13812 else if (TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
)
13816 return (better1
> 0) - (better2
> 0);
13819 /* Determine which of two partial specializations is more specialized.
13821 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13822 to the first partial specialization. The TREE_VALUE is the
13823 innermost set of template parameters for the partial
13824 specialization. PAT2 is similar, but for the second template.
13826 Return 1 if the first partial specialization is more specialized;
13827 -1 if the second is more specialized; 0 if neither is more
13830 See [temp.class.order] for information about determining which of
13831 two templates is more specialized. */
13834 more_specialized_class (tree pat1
, tree pat2
)
13839 bool any_deductions
= false;
13841 tmpl1
= TREE_TYPE (pat1
);
13842 tmpl2
= TREE_TYPE (pat2
);
13844 /* Just like what happens for functions, if we are ordering between
13845 different class template specializations, we may encounter dependent
13846 types in the arguments, and we need our dependency check functions
13847 to behave correctly. */
13848 ++processing_template_decl
;
13849 targs
= get_class_bindings (TREE_VALUE (pat1
),
13850 CLASSTYPE_TI_ARGS (tmpl1
),
13851 CLASSTYPE_TI_ARGS (tmpl2
));
13855 any_deductions
= true;
13858 targs
= get_class_bindings (TREE_VALUE (pat2
),
13859 CLASSTYPE_TI_ARGS (tmpl2
),
13860 CLASSTYPE_TI_ARGS (tmpl1
));
13864 any_deductions
= true;
13866 --processing_template_decl
;
13868 /* In the case of a tie where at least one of the class templates
13869 has a parameter pack at the end, the template with the most
13870 non-packed parameters wins. */
13873 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
13874 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
13876 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
13877 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
13878 int len1
= TREE_VEC_LENGTH (args1
);
13879 int len2
= TREE_VEC_LENGTH (args2
);
13881 /* We don't count the pack expansion at the end. */
13882 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
13884 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
13889 else if (len1
< len2
)
13896 /* Return the template arguments that will produce the function signature
13897 DECL from the function template FN, with the explicit template
13898 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13899 also match. Return NULL_TREE if no satisfactory arguments could be
13903 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
13905 int ntparms
= DECL_NTPARMS (fn
);
13906 tree targs
= make_tree_vec (ntparms
);
13908 tree decl_arg_types
;
13910 /* Substitute the explicit template arguments into the type of DECL.
13911 The call to fn_type_unification will handle substitution into the
13913 decl_type
= TREE_TYPE (decl
);
13914 if (explicit_args
&& uses_template_parms (decl_type
))
13917 tree converted_args
;
13919 if (DECL_TEMPLATE_INFO (decl
))
13920 tmpl
= DECL_TI_TEMPLATE (decl
);
13922 /* We can get here for some invalid specializations. */
13926 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
13927 explicit_args
, NULL_TREE
,
13929 /*require_all_args=*/false,
13930 /*use_default_args=*/false);
13931 if (converted_args
== error_mark_node
)
13934 decl_type
= tsubst (decl_type
, converted_args
, tf_none
, NULL_TREE
);
13935 if (decl_type
== error_mark_node
)
13939 /* Never do unification on the 'this' parameter. */
13940 decl_arg_types
= skip_artificial_parms_for (decl
,
13941 TYPE_ARG_TYPES (decl_type
));
13943 if (fn_type_unification (fn
, explicit_args
, targs
,
13945 (check_rettype
|| DECL_CONV_FN_P (fn
)
13946 ? TREE_TYPE (decl_type
) : NULL_TREE
),
13947 DEDUCE_EXACT
, LOOKUP_NORMAL
))
13953 /* Return the innermost template arguments that, when applied to a
13954 template specialization whose innermost template parameters are
13955 TPARMS, and whose specialization arguments are PARMS, yield the
13958 For example, suppose we have:
13960 template <class T, class U> struct S {};
13961 template <class T> struct S<T*, int> {};
13963 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13964 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13965 int}. The resulting vector will be {double}, indicating that `T'
13966 is bound to `double'. */
13969 get_class_bindings (tree tparms
, tree spec_args
, tree args
)
13971 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
13973 tree innermost_deduced_args
;
13975 innermost_deduced_args
= make_tree_vec (ntparms
);
13976 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
13978 deduced_args
= copy_node (args
);
13979 SET_TMPL_ARGS_LEVEL (deduced_args
,
13980 TMPL_ARGS_DEPTH (deduced_args
),
13981 innermost_deduced_args
);
13984 deduced_args
= innermost_deduced_args
;
13986 if (unify (tparms
, deduced_args
,
13987 INNERMOST_TEMPLATE_ARGS (spec_args
),
13988 INNERMOST_TEMPLATE_ARGS (args
),
13992 for (i
= 0; i
< ntparms
; ++i
)
13993 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
13996 /* Verify that nondeduced template arguments agree with the type
13997 obtained from argument deduction.
14001 struct A { typedef int X; };
14002 template <class T, class U> struct C {};
14003 template <class T> struct C<T, typename T::X> {};
14005 Then with the instantiation `C<A, int>', we can deduce that
14006 `T' is `A' but unify () does not check whether `typename T::X'
14008 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
14009 if (spec_args
== error_mark_node
14010 /* We only need to check the innermost arguments; the other
14011 arguments will always agree. */
14012 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
14013 INNERMOST_TEMPLATE_ARGS (args
)))
14016 /* Now that we have bindings for all of the template arguments,
14017 ensure that the arguments deduced for the template template
14018 parameters have compatible template parameter lists. See the use
14019 of template_template_parm_bindings_ok_p in fn_type_unification
14020 for more information. */
14021 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
14024 return deduced_args
;
14027 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
14028 Return the TREE_LIST node with the most specialized template, if
14029 any. If there is no most specialized template, the error_mark_node
14032 Note that this function does not look at, or modify, the
14033 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
14034 returned is one of the elements of INSTANTIATIONS, callers may
14035 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
14036 and retrieve it from the value returned. */
14039 most_specialized_instantiation (tree templates
)
14043 ++processing_template_decl
;
14046 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
14050 if (get_bindings (TREE_VALUE (champ
),
14051 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
14052 NULL_TREE
, /*check_ret=*/false))
14055 if (get_bindings (TREE_VALUE (fn
),
14056 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
14057 NULL_TREE
, /*check_ret=*/false))
14064 /* Equally specialized, move to next function. If there
14065 is no next function, nothing's most specialized. */
14066 fn
= TREE_CHAIN (fn
);
14074 /* Now verify that champ is better than everything earlier in the
14075 instantiation list. */
14076 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
14077 if (get_bindings (TREE_VALUE (champ
),
14078 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
14079 NULL_TREE
, /*check_ret=*/false)
14080 || !get_bindings (TREE_VALUE (fn
),
14081 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
14082 NULL_TREE
, /*check_ret=*/false))
14088 processing_template_decl
--;
14091 return error_mark_node
;
14096 /* If DECL is a specialization of some template, return the most
14097 general such template. Otherwise, returns NULL_TREE.
14099 For example, given:
14101 template <class T> struct S { template <class U> void f(U); };
14103 if TMPL is `template <class U> void S<int>::f(U)' this will return
14104 the full template. This function will not trace past partial
14105 specializations, however. For example, given in addition:
14107 template <class T> struct S<T*> { template <class U> void f(U); };
14109 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14110 `template <class T> template <class U> S<T*>::f(U)'. */
14113 most_general_template (tree decl
)
14115 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
14116 an immediate specialization. */
14117 if (TREE_CODE (decl
) == FUNCTION_DECL
)
14119 if (DECL_TEMPLATE_INFO (decl
)) {
14120 decl
= DECL_TI_TEMPLATE (decl
);
14122 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
14123 template friend. */
14124 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
14130 /* Look for more and more general templates. */
14131 while (DECL_TEMPLATE_INFO (decl
))
14133 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
14134 (See cp-tree.h for details.) */
14135 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
14138 if (CLASS_TYPE_P (TREE_TYPE (decl
))
14139 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
14142 /* Stop if we run into an explicitly specialized class template. */
14143 if (!DECL_NAMESPACE_SCOPE_P (decl
)
14144 && DECL_CONTEXT (decl
)
14145 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
14148 decl
= DECL_TI_TEMPLATE (decl
);
14154 /* Return the most specialized of the class template partial
14155 specializations of TMPL which can produce TYPE, a specialization of
14156 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
14157 a _TYPE node corresponding to the partial specialization, while the
14158 TREE_PURPOSE is the set of template arguments that must be
14159 substituted into the TREE_TYPE in order to generate TYPE.
14161 If the choice of partial specialization is ambiguous, a diagnostic
14162 is issued, and the error_mark_node is returned. If there are no
14163 partial specializations of TMPL matching TYPE, then NULL_TREE is
14167 most_specialized_class (tree type
, tree tmpl
)
14169 tree list
= NULL_TREE
;
14175 tree outer_args
= NULL_TREE
;
14177 tmpl
= most_general_template (tmpl
);
14178 args
= CLASSTYPE_TI_ARGS (type
);
14180 /* For determining which partial specialization to use, only the
14181 innermost args are interesting. */
14182 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
14184 outer_args
= strip_innermost_template_args (args
, 1);
14185 args
= INNERMOST_TEMPLATE_ARGS (args
);
14188 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
14190 tree partial_spec_args
;
14192 tree parms
= TREE_VALUE (t
);
14194 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
14199 ++processing_template_decl
;
14201 /* Discard the outer levels of args, and then substitute in the
14202 template args from the enclosing class. */
14203 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
14204 partial_spec_args
= tsubst_template_args
14205 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
14207 /* PARMS already refers to just the innermost parms, but the
14208 template parms in partial_spec_args had their levels lowered
14209 by tsubst, so we need to do the same for the parm list. We
14210 can't just tsubst the TREE_VEC itself, as tsubst wants to
14211 treat a TREE_VEC as an argument vector. */
14212 parms
= copy_node (parms
);
14213 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
14214 TREE_VEC_ELT (parms
, i
) =
14215 tsubst (TREE_VEC_ELT (parms
, i
), outer_args
, tf_none
, NULL_TREE
);
14217 --processing_template_decl
;
14219 spec_args
= get_class_bindings (parms
,
14225 spec_args
= add_to_template_args (outer_args
, spec_args
);
14226 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
14227 TREE_TYPE (list
) = TREE_TYPE (t
);
14234 ambiguous_p
= false;
14237 t
= TREE_CHAIN (t
);
14238 for (; t
; t
= TREE_CHAIN (t
))
14240 fate
= more_specialized_class (champ
, t
);
14247 t
= TREE_CHAIN (t
);
14250 ambiguous_p
= true;
14259 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
14261 fate
= more_specialized_class (champ
, t
);
14264 ambiguous_p
= true;
14271 const char *str
= "candidates are:";
14272 error ("ambiguous class template instantiation for %q#T", type
);
14273 for (t
= list
; t
; t
= TREE_CHAIN (t
))
14275 error ("%s %+#T", str
, TREE_TYPE (t
));
14278 return error_mark_node
;
14284 /* Explicitly instantiate DECL. */
14287 do_decl_instantiation (tree decl
, tree storage
)
14289 tree result
= NULL_TREE
;
14292 if (!decl
|| decl
== error_mark_node
)
14293 /* An error occurred, for which grokdeclarator has already issued
14294 an appropriate message. */
14296 else if (! DECL_LANG_SPECIFIC (decl
))
14298 error ("explicit instantiation of non-template %q#D", decl
);
14301 else if (TREE_CODE (decl
) == VAR_DECL
)
14303 /* There is an asymmetry here in the way VAR_DECLs and
14304 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14305 the latter, the DECL we get back will be marked as a
14306 template instantiation, and the appropriate
14307 DECL_TEMPLATE_INFO will be set up. This does not happen for
14308 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14309 should handle VAR_DECLs as it currently handles
14311 if (!DECL_CLASS_SCOPE_P (decl
))
14313 error ("%qD is not a static data member of a class template", decl
);
14316 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
14317 if (!result
|| TREE_CODE (result
) != VAR_DECL
)
14319 error ("no matching template for %qD found", decl
);
14322 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
14324 error ("type %qT for explicit instantiation %qD does not match "
14325 "declared type %qT", TREE_TYPE (result
), decl
,
14330 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
14332 error ("explicit instantiation of %q#D", decl
);
14338 /* Check for various error cases. Note that if the explicit
14339 instantiation is valid the RESULT will currently be marked as an
14340 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
14341 until we get here. */
14343 if (DECL_TEMPLATE_SPECIALIZATION (result
))
14345 /* DR 259 [temp.spec].
14347 Both an explicit instantiation and a declaration of an explicit
14348 specialization shall not appear in a program unless the explicit
14349 instantiation follows a declaration of the explicit specialization.
14351 For a given set of template parameters, if an explicit
14352 instantiation of a template appears after a declaration of an
14353 explicit specialization for that template, the explicit
14354 instantiation has no effect. */
14357 else if (DECL_EXPLICIT_INSTANTIATION (result
))
14361 No program shall explicitly instantiate any template more
14364 We check DECL_NOT_REALLY_EXTERN so as not to complain when
14365 the first instantiation was `extern' and the second is not,
14366 and EXTERN_P for the opposite case. */
14367 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
14368 pedwarn ("duplicate explicit instantiation of %q#D", result
);
14369 /* If an "extern" explicit instantiation follows an ordinary
14370 explicit instantiation, the template is instantiated. */
14374 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
14376 error ("no matching template for %qD found", result
);
14379 else if (!DECL_TEMPLATE_INFO (result
))
14381 pedwarn ("explicit instantiation of non-template %q#D", result
);
14385 if (storage
== NULL_TREE
)
14387 else if (storage
== ridpointers
[(int) RID_EXTERN
])
14389 if (pedantic
&& !in_system_header
)
14390 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
14395 error ("storage class %qD applied to template instantiation", storage
);
14397 check_explicit_instantiation_namespace (result
);
14398 mark_decl_instantiated (result
, extern_p
);
14400 instantiate_decl (result
, /*defer_ok=*/1,
14401 /*expl_inst_class_mem_p=*/false);
14405 mark_class_instantiated (tree t
, int extern_p
)
14407 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
14408 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
14409 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
14410 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
14413 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
14414 rest_of_type_compilation (t
, 1);
14418 /* Called from do_type_instantiation through binding_table_foreach to
14419 do recursive instantiation for the type bound in ENTRY. */
14421 bt_instantiate_type_proc (binding_entry entry
, void *data
)
14423 tree storage
= *(tree
*) data
;
14425 if (IS_AGGR_TYPE (entry
->type
)
14426 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
14427 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
14430 /* Called from do_type_instantiation to instantiate a member
14431 (a member function or a static member variable) of an
14432 explicitly instantiated class template. */
14434 instantiate_class_member (tree decl
, int extern_p
)
14436 mark_decl_instantiated (decl
, extern_p
);
14438 instantiate_decl (decl
, /*defer_ok=*/1,
14439 /*expl_inst_class_mem_p=*/true);
14442 /* Perform an explicit instantiation of template class T. STORAGE, if
14443 non-null, is the RID for extern, inline or static. COMPLAIN is
14444 nonzero if this is called from the parser, zero if called recursively,
14445 since the standard is unclear (as detailed below). */
14448 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
14453 int previous_instantiation_extern_p
= 0;
14455 if (TREE_CODE (t
) == TYPE_DECL
)
14458 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
14460 error ("explicit instantiation of non-template type %qT", t
);
14466 if (!COMPLETE_TYPE_P (t
))
14468 if (complain
& tf_error
)
14469 error ("explicit instantiation of %q#T before definition of template",
14474 if (storage
!= NULL_TREE
)
14476 if (pedantic
&& !in_system_header
)
14477 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
14480 if (storage
== ridpointers
[(int) RID_INLINE
])
14482 else if (storage
== ridpointers
[(int) RID_EXTERN
])
14484 else if (storage
== ridpointers
[(int) RID_STATIC
])
14488 error ("storage class %qD applied to template instantiation",
14494 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
14496 /* DR 259 [temp.spec].
14498 Both an explicit instantiation and a declaration of an explicit
14499 specialization shall not appear in a program unless the explicit
14500 instantiation follows a declaration of the explicit specialization.
14502 For a given set of template parameters, if an explicit
14503 instantiation of a template appears after a declaration of an
14504 explicit specialization for that template, the explicit
14505 instantiation has no effect. */
14508 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
14512 No program shall explicitly instantiate any template more
14515 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
14516 instantiation was `extern'. If EXTERN_P then the second is.
14517 These cases are OK. */
14518 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
14520 if (!previous_instantiation_extern_p
&& !extern_p
14521 && (complain
& tf_error
))
14522 pedwarn ("duplicate explicit instantiation of %q#T", t
);
14524 /* If we've already instantiated the template, just return now. */
14525 if (!CLASSTYPE_INTERFACE_ONLY (t
))
14529 check_explicit_instantiation_namespace (TYPE_NAME (t
));
14530 mark_class_instantiated (t
, extern_p
);
14538 /* In contrast to implicit instantiation, where only the
14539 declarations, and not the definitions, of members are
14540 instantiated, we have here:
14544 The explicit instantiation of a class template specialization
14545 implies the instantiation of all of its members not
14546 previously explicitly specialized in the translation unit
14547 containing the explicit instantiation.
14549 Of course, we can't instantiate member template classes, since
14550 we don't have any arguments for them. Note that the standard
14551 is unclear on whether the instantiation of the members are
14552 *explicit* instantiations or not. However, the most natural
14553 interpretation is that it should be an explicit instantiation. */
14556 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
14557 if (TREE_CODE (tmp
) == FUNCTION_DECL
14558 && DECL_TEMPLATE_INSTANTIATION (tmp
))
14559 instantiate_class_member (tmp
, extern_p
);
14561 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
14562 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
14563 instantiate_class_member (tmp
, extern_p
);
14565 if (CLASSTYPE_NESTED_UTDS (t
))
14566 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
14567 bt_instantiate_type_proc
, &storage
);
14571 /* Given a function DECL, which is a specialization of TMPL, modify
14572 DECL to be a re-instantiation of TMPL with the same template
14573 arguments. TMPL should be the template into which tsubst'ing
14574 should occur for DECL, not the most general template.
14576 One reason for doing this is a scenario like this:
14579 void f(const T&, int i);
14581 void g() { f(3, 7); }
14584 void f(const T& t, const int i) { }
14586 Note that when the template is first instantiated, with
14587 instantiate_template, the resulting DECL will have no name for the
14588 first parameter, and the wrong type for the second. So, when we go
14589 to instantiate the DECL, we regenerate it. */
14592 regenerate_decl_from_template (tree decl
, tree tmpl
)
14594 /* The arguments used to instantiate DECL, from the most general
14599 args
= DECL_TI_ARGS (decl
);
14600 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
14602 /* Make sure that we can see identifiers, and compute access
14604 push_access_scope (decl
);
14606 if (TREE_CODE (decl
) == FUNCTION_DECL
)
14614 args_depth
= TMPL_ARGS_DEPTH (args
);
14615 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
14616 if (args_depth
> parms_depth
)
14617 args
= get_innermost_template_args (args
, parms_depth
);
14619 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
14620 args
, tf_error
, NULL_TREE
);
14622 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
14625 /* Merge parameter declarations. */
14626 decl_parm
= skip_artificial_parms_for (decl
,
14627 DECL_ARGUMENTS (decl
));
14629 = skip_artificial_parms_for (code_pattern
,
14630 DECL_ARGUMENTS (code_pattern
));
14631 while (decl_parm
&& !FUNCTION_PARAMETER_PACK_P (pattern_parm
))
14636 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
14637 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
14638 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
14640 parm_type
= type_decays_to (parm_type
);
14641 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
14642 TREE_TYPE (decl_parm
) = parm_type
;
14643 attributes
= DECL_ATTRIBUTES (pattern_parm
);
14644 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
14646 DECL_ATTRIBUTES (decl_parm
) = attributes
;
14647 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
14649 decl_parm
= TREE_CHAIN (decl_parm
);
14650 pattern_parm
= TREE_CHAIN (pattern_parm
);
14652 /* Merge any parameters that match with the function parameter
14654 if (pattern_parm
&& FUNCTION_PARAMETER_PACK_P (pattern_parm
))
14657 tree expanded_types
;
14658 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14659 the parameters in this function parameter pack. */
14660 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
14661 args
, tf_error
, NULL_TREE
);
14662 len
= TREE_VEC_LENGTH (expanded_types
);
14663 for (i
= 0; i
< len
; i
++)
14668 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
14669 /* Rename the parameter to include the index. */
14670 DECL_NAME (decl_parm
) =
14671 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
14672 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
14673 parm_type
= type_decays_to (parm_type
);
14674 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
14675 TREE_TYPE (decl_parm
) = parm_type
;
14676 attributes
= DECL_ATTRIBUTES (pattern_parm
);
14677 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
14679 DECL_ATTRIBUTES (decl_parm
) = attributes
;
14680 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
14682 decl_parm
= TREE_CHAIN (decl_parm
);
14685 /* Merge additional specifiers from the CODE_PATTERN. */
14686 if (DECL_DECLARED_INLINE_P (code_pattern
)
14687 && !DECL_DECLARED_INLINE_P (decl
))
14688 DECL_DECLARED_INLINE_P (decl
) = 1;
14689 if (DECL_INLINE (code_pattern
) && !DECL_INLINE (decl
))
14690 DECL_INLINE (decl
) = 1;
14692 else if (TREE_CODE (decl
) == VAR_DECL
)
14693 DECL_INITIAL (decl
) =
14694 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
14695 tf_error
, DECL_TI_TEMPLATE (decl
),
14696 /*integral_constant_expression_p=*/false);
14698 gcc_unreachable ();
14700 pop_access_scope (decl
);
14703 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14704 substituted to get DECL. */
14707 template_for_substitution (tree decl
)
14709 tree tmpl
= DECL_TI_TEMPLATE (decl
);
14711 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14712 for the instantiation. This is not always the most general
14713 template. Consider, for example:
14716 struct S { template <class U> void f();
14717 template <> void f<int>(); };
14719 and an instantiation of S<double>::f<int>. We want TD to be the
14720 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14721 while (/* An instantiation cannot have a definition, so we need a
14722 more general template. */
14723 DECL_TEMPLATE_INSTANTIATION (tmpl
)
14724 /* We must also deal with friend templates. Given:
14726 template <class T> struct S {
14727 template <class U> friend void f() {};
14730 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14731 so far as the language is concerned, but that's still
14732 where we get the pattern for the instantiation from. On
14733 other hand, if the definition comes outside the class, say:
14735 template <class T> struct S {
14736 template <class U> friend void f();
14738 template <class U> friend void f() {}
14740 we don't need to look any further. That's what the check for
14741 DECL_INITIAL is for. */
14742 || (TREE_CODE (decl
) == FUNCTION_DECL
14743 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
14744 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
14746 /* The present template, TD, should not be a definition. If it
14747 were a definition, we should be using it! Note that we
14748 cannot restructure the loop to just keep going until we find
14749 a template with a definition, since that might go too far if
14750 a specialization was declared, but not defined. */
14751 gcc_assert (TREE_CODE (decl
) != VAR_DECL
14752 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
14754 /* Fetch the more general template. */
14755 tmpl
= DECL_TI_TEMPLATE (tmpl
);
14761 /* Produce the definition of D, a _DECL generated from a template. If
14762 DEFER_OK is nonzero, then we don't have to actually do the
14763 instantiation now; we just have to do it sometime. Normally it is
14764 an error if this is an explicit instantiation but D is undefined.
14765 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14766 explicitly instantiated class template. */
14769 instantiate_decl (tree d
, int defer_ok
,
14770 bool expl_inst_class_mem_p
)
14772 tree tmpl
= DECL_TI_TEMPLATE (d
);
14779 bool pattern_defined
;
14781 location_t saved_loc
= input_location
;
14782 int saved_in_system_header
= in_system_header
;
14785 /* This function should only be used to instantiate templates for
14786 functions and static member variables. */
14787 gcc_assert (TREE_CODE (d
) == FUNCTION_DECL
14788 || TREE_CODE (d
) == VAR_DECL
);
14790 /* Variables are never deferred; if instantiation is required, they
14791 are instantiated right away. That allows for better code in the
14792 case that an expression refers to the value of the variable --
14793 if the variable has a constant value the referring expression can
14794 take advantage of that fact. */
14795 if (TREE_CODE (d
) == VAR_DECL
)
14798 /* Don't instantiate cloned functions. Instead, instantiate the
14799 functions they cloned. */
14800 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
14801 d
= DECL_CLONED_FUNCTION (d
);
14803 if (DECL_TEMPLATE_INSTANTIATED (d
))
14804 /* D has already been instantiated. It might seem reasonable to
14805 check whether or not D is an explicit instantiation, and, if so,
14806 stop here. But when an explicit instantiation is deferred
14807 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14808 is set, even though we still need to do the instantiation. */
14811 /* If we already have a specialization of this declaration, then
14812 there's no reason to instantiate it. Note that
14813 retrieve_specialization gives us both instantiations and
14814 specializations, so we must explicitly check
14815 DECL_TEMPLATE_SPECIALIZATION. */
14816 gen_tmpl
= most_general_template (tmpl
);
14817 gen_args
= DECL_TI_ARGS (d
);
14818 spec
= retrieve_specialization (gen_tmpl
, gen_args
,
14819 /*class_specializations_p=*/false);
14820 if (spec
!= NULL_TREE
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
14823 /* This needs to happen before any tsubsting. */
14824 if (! push_tinst_level (d
))
14827 timevar_push (TV_PARSE
);
14829 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14830 for the instantiation. */
14831 td
= template_for_substitution (d
);
14832 code_pattern
= DECL_TEMPLATE_RESULT (td
);
14834 /* We should never be trying to instantiate a member of a class
14835 template or partial specialization. */
14836 gcc_assert (d
!= code_pattern
);
14838 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
14839 || DECL_TEMPLATE_SPECIALIZATION (td
))
14840 /* In the case of a friend template whose definition is provided
14841 outside the class, we may have too many arguments. Drop the
14842 ones we don't need. The same is true for specializations. */
14843 args
= get_innermost_template_args
14844 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
14848 if (TREE_CODE (d
) == FUNCTION_DECL
)
14849 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
);
14851 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
14853 /* We may be in the middle of deferred access check. Disable it now. */
14854 push_deferring_access_checks (dk_no_deferred
);
14856 /* Unless an explicit instantiation directive has already determined
14857 the linkage of D, remember that a definition is available for
14859 if (pattern_defined
14860 && !DECL_INTERFACE_KNOWN (d
)
14861 && !DECL_NOT_REALLY_EXTERN (d
))
14862 mark_definable (d
);
14864 input_location
= DECL_SOURCE_LOCATION (d
);
14865 in_system_header
= DECL_IN_SYSTEM_HEADER (d
);
14867 /* If D is a member of an explicitly instantiated class template,
14868 and no definition is available, treat it like an implicit
14870 if (!pattern_defined
&& expl_inst_class_mem_p
14871 && DECL_EXPLICIT_INSTANTIATION (d
))
14873 /* Leave linkage flags alone on instantiations with anonymous
14875 if (TREE_PUBLIC (d
))
14877 DECL_NOT_REALLY_EXTERN (d
) = 0;
14878 DECL_INTERFACE_KNOWN (d
) = 0;
14880 SET_DECL_IMPLICIT_INSTANTIATION (d
);
14885 /* Recheck the substitutions to obtain any warning messages
14886 about ignoring cv qualifiers. */
14887 tree gen
= DECL_TEMPLATE_RESULT (gen_tmpl
);
14888 tree type
= TREE_TYPE (gen
);
14890 /* Make sure that we can see identifiers, and compute access
14891 correctly. D is already the target FUNCTION_DECL with the
14893 push_access_scope (d
);
14895 if (TREE_CODE (gen
) == FUNCTION_DECL
)
14897 tsubst (DECL_ARGUMENTS (gen
), gen_args
, tf_warning_or_error
, d
);
14898 tsubst_exception_specification (type
, gen_args
, tf_warning_or_error
,
14900 /* Don't simply tsubst the function type, as that will give
14901 duplicate warnings about poor parameter qualifications.
14902 The function arguments are the same as the decl_arguments
14903 without the top level cv qualifiers. */
14904 type
= TREE_TYPE (type
);
14906 tsubst (type
, gen_args
, tf_warning_or_error
, d
);
14908 pop_access_scope (d
);
14911 /* Check to see whether we know that this template will be
14912 instantiated in some other file, as with "extern template"
14914 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
14915 /* In general, we do not instantiate such templates... */
14917 /* ... but we instantiate inline functions so that we can inline
14919 && ! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
))
14920 /* ... we instantiate static data members whose values are
14921 needed in integral constant expressions. */
14922 && ! (TREE_CODE (d
) == VAR_DECL
14923 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d
)))
14925 /* Defer all other templates, unless we have been explicitly
14926 forbidden from doing so. */
14927 if (/* If there is no definition, we cannot instantiate the
14930 /* If it's OK to postpone instantiation, do so. */
14932 /* If this is a static data member that will be defined
14933 elsewhere, we don't want to instantiate the entire data
14934 member, but we do want to instantiate the initializer so that
14935 we can substitute that elsewhere. */
14936 || (external_p
&& TREE_CODE (d
) == VAR_DECL
))
14938 /* The definition of the static data member is now required so
14939 we must substitute the initializer. */
14940 if (TREE_CODE (d
) == VAR_DECL
14941 && !DECL_INITIAL (d
)
14942 && DECL_INITIAL (code_pattern
))
14947 ns
= decl_namespace_context (d
);
14948 push_nested_namespace (ns
);
14949 push_nested_class (DECL_CONTEXT (d
));
14950 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
14952 tf_warning_or_error
, NULL_TREE
,
14953 /*integral_constant_expression_p=*/false);
14954 cp_finish_decl (d
, init
, /*init_const_expr_p=*/false,
14955 /*asmspec_tree=*/NULL_TREE
,
14956 LOOKUP_ONLYCONVERTING
);
14957 pop_nested_class ();
14958 pop_nested_namespace (ns
);
14961 /* We restore the source position here because it's used by
14962 add_pending_template. */
14963 input_location
= saved_loc
;
14965 if (at_eof
&& !pattern_defined
14966 && DECL_EXPLICIT_INSTANTIATION (d
))
14969 The definition of a non-exported function template, a
14970 non-exported member function template, or a non-exported
14971 member function or static data member of a class template
14972 shall be present in every translation unit in which it is
14973 explicitly instantiated. */
14975 ("explicit instantiation of %qD but no definition available", d
);
14977 /* ??? Historically, we have instantiated inline functions, even
14978 when marked as "extern template". */
14979 if (!(external_p
&& TREE_CODE (d
) == VAR_DECL
))
14980 add_pending_template (d
);
14983 /* Tell the repository that D is available in this translation unit
14984 -- and see if it is supposed to be instantiated here. */
14985 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
14987 /* In a PCH file, despite the fact that the repository hasn't
14988 requested instantiation in the PCH it is still possible that
14989 an instantiation will be required in a file that includes the
14992 add_pending_template (d
);
14993 /* Instantiate inline functions so that the inliner can do its
14994 job, even though we'll not be emitting a copy of this
14996 if (!(TREE_CODE (d
) == FUNCTION_DECL
14997 && flag_inline_trees
14998 && DECL_DECLARED_INLINE_P (d
)))
15002 need_push
= !cfun
|| !global_bindings_p ();
15004 push_to_top_level ();
15006 /* Mark D as instantiated so that recursive calls to
15007 instantiate_decl do not try to instantiate it again. */
15008 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
15010 /* Regenerate the declaration in case the template has been modified
15011 by a subsequent redeclaration. */
15012 regenerate_decl_from_template (d
, td
);
15014 /* We already set the file and line above. Reset them now in case
15015 they changed as a result of calling regenerate_decl_from_template. */
15016 input_location
= DECL_SOURCE_LOCATION (d
);
15018 if (TREE_CODE (d
) == VAR_DECL
)
15022 /* Clear out DECL_RTL; whatever was there before may not be right
15023 since we've reset the type of the declaration. */
15024 SET_DECL_RTL (d
, NULL_RTX
);
15025 DECL_IN_AGGR_P (d
) = 0;
15027 /* The initializer is placed in DECL_INITIAL by
15028 regenerate_decl_from_template. Pull it out so that
15029 finish_decl can process it. */
15030 init
= DECL_INITIAL (d
);
15031 DECL_INITIAL (d
) = NULL_TREE
;
15032 DECL_INITIALIZED_P (d
) = 0;
15034 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
15035 initializer. That function will defer actual emission until
15036 we have a chance to determine linkage. */
15037 DECL_EXTERNAL (d
) = 0;
15039 /* Enter the scope of D so that access-checking works correctly. */
15040 push_nested_class (DECL_CONTEXT (d
));
15041 finish_decl (d
, init
, NULL_TREE
);
15042 pop_nested_class ();
15044 else if (TREE_CODE (d
) == FUNCTION_DECL
)
15046 htab_t saved_local_specializations
;
15051 /* Save away the current list, in case we are instantiating one
15052 template from within the body of another. */
15053 saved_local_specializations
= local_specializations
;
15055 /* Set up the list of local specializations. */
15056 local_specializations
= htab_create (37,
15057 hash_local_specialization
,
15058 eq_local_specializations
,
15061 /* Set up context. */
15062 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
15064 /* Create substitution entries for the parameters. */
15065 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
15066 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
15067 spec_parm
= DECL_ARGUMENTS (d
);
15068 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
15070 register_local_specialization (spec_parm
, tmpl_parm
);
15071 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
15072 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
15074 while (tmpl_parm
&& !FUNCTION_PARAMETER_PACK_P (tmpl_parm
))
15076 register_local_specialization (spec_parm
, tmpl_parm
);
15077 tmpl_parm
= TREE_CHAIN (tmpl_parm
);
15078 spec_parm
= TREE_CHAIN (spec_parm
);
15080 if (tmpl_parm
&& FUNCTION_PARAMETER_PACK_P (tmpl_parm
))
15082 /* Collect all of the extra "packed" parameters into an
15086 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
15087 tree argtypepack
= make_node (TYPE_ARGUMENT_PACK
);
15091 /* Count how many parameters remain. */
15092 for (t
= spec_parm
; t
; t
= TREE_CHAIN (t
))
15095 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
15096 parmvec
= make_tree_vec (len
);
15097 parmtypevec
= make_tree_vec (len
);
15098 for(i
= 0; i
< len
; i
++, spec_parm
= TREE_CHAIN (spec_parm
))
15100 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
15101 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
15104 /* Build the argument packs. */
15105 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
15106 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
15107 TREE_TYPE (argpack
) = argtypepack
;
15109 /* Register the (value) argument pack as a specialization of
15110 TMPL_PARM, then move on. */
15111 register_local_specialization (argpack
, tmpl_parm
);
15112 tmpl_parm
= TREE_CHAIN (tmpl_parm
);
15114 gcc_assert (!spec_parm
);
15116 /* Substitute into the body of the function. */
15117 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
15118 tf_warning_or_error
, tmpl
,
15119 /*integral_constant_expression_p=*/false);
15121 /* Set the current input_location to the end of the function
15122 so that finish_function knows where we are. */
15123 input_location
= DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
15125 /* We don't need the local specializations any more. */
15126 htab_delete (local_specializations
);
15127 local_specializations
= saved_local_specializations
;
15129 /* Finish the function. */
15130 d
= finish_function (0);
15131 expand_or_defer_fn (d
);
15134 /* We're not deferring instantiation any more. */
15135 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
15138 pop_from_top_level ();
15141 input_location
= saved_loc
;
15142 in_system_header
= saved_in_system_header
;
15143 pop_deferring_access_checks ();
15144 pop_tinst_level ();
15146 timevar_pop (TV_PARSE
);
15151 /* Run through the list of templates that we wish we could
15152 instantiate, and instantiate any we can. RETRIES is the
15153 number of times we retry pending template instantiation. */
15156 instantiate_pending_templates (int retries
)
15159 location_t saved_loc
= input_location
;
15160 int saved_in_system_header
= in_system_header
;
15162 /* Instantiating templates may trigger vtable generation. This in turn
15163 may require further template instantiations. We place a limit here
15164 to avoid infinite loop. */
15165 if (pending_templates
&& retries
>= max_tinst_depth
)
15167 tree decl
= pending_templates
->tinst
->decl
;
15169 error ("template instantiation depth exceeds maximum of %d"
15170 " instantiating %q+D, possibly from virtual table generation"
15171 " (use -ftemplate-depth-NN to increase the maximum)",
15172 max_tinst_depth
, decl
);
15173 if (TREE_CODE (decl
) == FUNCTION_DECL
)
15174 /* Pretend that we defined it. */
15175 DECL_INITIAL (decl
) = error_mark_node
;
15181 struct pending_template
**t
= &pending_templates
;
15182 struct pending_template
*last
= NULL
;
15186 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
15187 bool complete
= false;
15189 if (TYPE_P (instantiation
))
15193 if (!COMPLETE_TYPE_P (instantiation
))
15195 instantiate_class_template (instantiation
);
15196 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
15197 for (fn
= TYPE_METHODS (instantiation
);
15199 fn
= TREE_CHAIN (fn
))
15200 if (! DECL_ARTIFICIAL (fn
))
15201 instantiate_decl (fn
,
15203 /*expl_inst_class_mem_p=*/false);
15204 if (COMPLETE_TYPE_P (instantiation
))
15208 complete
= COMPLETE_TYPE_P (instantiation
);
15212 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
15213 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
15216 = instantiate_decl (instantiation
,
15218 /*expl_inst_class_mem_p=*/false);
15219 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
15223 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
15224 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
15228 /* If INSTANTIATION has been instantiated, then we don't
15229 need to consider it again in the future. */
15237 current_tinst_level
= NULL
;
15239 last_pending_template
= last
;
15241 while (reconsider
);
15243 input_location
= saved_loc
;
15244 in_system_header
= saved_in_system_header
;
15247 /* Substitute ARGVEC into T, which is a list of initializers for
15248 either base class or a non-static data member. The TREE_PURPOSEs
15249 are DECLs, and the TREE_VALUEs are the initializer values. Used by
15250 instantiate_decl. */
15253 tsubst_initializer_list (tree t
, tree argvec
)
15255 tree inits
= NULL_TREE
;
15257 for (; t
; t
= TREE_CHAIN (t
))
15261 tree expanded_bases
= NULL_TREE
;
15262 tree expanded_arguments
= NULL_TREE
;
15265 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
15270 /* Expand the base class expansion type into separate base
15272 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
15273 tf_warning_or_error
,
15275 if (expanded_bases
== error_mark_node
)
15278 /* We'll be building separate TREE_LISTs of arguments for
15280 len
= TREE_VEC_LENGTH (expanded_bases
);
15281 expanded_arguments
= make_tree_vec (len
);
15282 for (i
= 0; i
< len
; i
++)
15283 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
15285 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15286 expand each argument in the TREE_VALUE of t. */
15287 expr
= make_node (EXPR_PACK_EXPANSION
);
15288 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
15289 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
15291 if (TREE_VALUE (t
) == void_type_node
)
15292 /* VOID_TYPE_NODE is used to indicate
15293 value-initialization. */
15295 for (i
= 0; i
< len
; i
++)
15296 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
15300 /* Substitute parameter packs into each argument in the
15302 in_base_initializer
= 1;
15303 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
15305 tree expanded_exprs
;
15307 /* Expand the argument. */
15308 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
15310 = tsubst_pack_expansion (expr
, argvec
,
15311 tf_warning_or_error
,
15314 /* Prepend each of the expanded expressions to the
15315 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15316 for (i
= 0; i
< len
; i
++)
15318 TREE_VEC_ELT (expanded_arguments
, i
) =
15319 tree_cons (NULL_TREE
,
15320 TREE_VEC_ELT (expanded_exprs
, i
),
15321 TREE_VEC_ELT (expanded_arguments
, i
));
15324 in_base_initializer
= 0;
15326 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15327 since we built them backwards. */
15328 for (i
= 0; i
< len
; i
++)
15330 TREE_VEC_ELT (expanded_arguments
, i
) =
15331 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
15336 for (i
= 0; i
< len
; ++i
)
15338 if (expanded_bases
)
15340 decl
= TREE_VEC_ELT (expanded_bases
, i
);
15341 decl
= expand_member_init (decl
);
15342 init
= TREE_VEC_ELT (expanded_arguments
, i
);
15346 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
15347 tf_warning_or_error
, NULL_TREE
);
15349 decl
= expand_member_init (decl
);
15350 if (decl
&& !DECL_P (decl
))
15351 in_base_initializer
= 1;
15353 init
= tsubst_expr (TREE_VALUE (t
), argvec
,
15354 tf_warning_or_error
, NULL_TREE
,
15355 /*integral_constant_expression_p=*/false);
15356 in_base_initializer
= 0;
15361 init
= build_tree_list (decl
, init
);
15362 TREE_CHAIN (init
) = inits
;
15370 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
15373 set_current_access_from_decl (tree decl
)
15375 if (TREE_PRIVATE (decl
))
15376 current_access_specifier
= access_private_node
;
15377 else if (TREE_PROTECTED (decl
))
15378 current_access_specifier
= access_protected_node
;
15380 current_access_specifier
= access_public_node
;
15383 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
15384 is the instantiation (which should have been created with
15385 start_enum) and ARGS are the template arguments to use. */
15388 tsubst_enum (tree tag
, tree newtag
, tree args
)
15392 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
15397 decl
= TREE_VALUE (e
);
15398 /* Note that in a template enum, the TREE_VALUE is the
15399 CONST_DECL, not the corresponding INTEGER_CST. */
15400 value
= tsubst_expr (DECL_INITIAL (decl
),
15401 args
, tf_warning_or_error
, NULL_TREE
,
15402 /*integral_constant_expression_p=*/true);
15404 /* Give this enumeration constant the correct access. */
15405 set_current_access_from_decl (decl
);
15407 /* Actually build the enumerator itself. */
15408 build_enumerator (DECL_NAME (decl
), value
, newtag
);
15411 finish_enum (newtag
);
15412 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
15413 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
15416 /* DECL is a FUNCTION_DECL that is a template specialization. Return
15417 its type -- but without substituting the innermost set of template
15418 arguments. So, innermost set of template parameters will appear in
15422 get_mostly_instantiated_function_type (tree decl
)
15430 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
15431 targs
= DECL_TI_ARGS (decl
);
15432 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
15433 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
15435 /* There should be as many levels of arguments as there are levels
15437 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
15439 fn_type
= TREE_TYPE (tmpl
);
15441 if (parm_depth
== 1)
15442 /* No substitution is necessary. */
15446 int i
, save_access_control
;
15449 /* Replace the innermost level of the TARGS with NULL_TREEs to
15450 let tsubst know not to substitute for those parameters. */
15451 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
15452 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
15453 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
15454 TMPL_ARGS_LEVEL (targs
, i
));
15455 SET_TMPL_ARGS_LEVEL (partial_args
,
15456 TMPL_ARGS_DEPTH (targs
),
15457 make_tree_vec (DECL_NTPARMS (tmpl
)));
15459 /* Disable access control as this function is used only during
15461 save_access_control
= flag_access_control
;
15462 flag_access_control
= 0;
15464 ++processing_template_decl
;
15465 /* Now, do the (partial) substitution to figure out the
15466 appropriate function type. */
15467 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
15468 --processing_template_decl
;
15470 /* Substitute into the template parameters to obtain the real
15471 innermost set of parameters. This step is important if the
15472 innermost set of template parameters contains value
15473 parameters whose types depend on outer template parameters. */
15474 TREE_VEC_LENGTH (partial_args
)--;
15475 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
15477 flag_access_control
= save_access_control
;
15483 /* Return truthvalue if we're processing a template different from
15484 the last one involved in diagnostics. */
15486 problematic_instantiation_changed (void)
15488 return last_template_error_tick
!= tinst_level_tick
;
15491 /* Remember current template involved in diagnostics. */
15493 record_last_problematic_instantiation (void)
15495 last_template_error_tick
= tinst_level_tick
;
15498 struct tinst_level
*
15499 current_instantiation (void)
15501 return current_tinst_level
;
15504 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15505 type. Return zero for ok, nonzero for disallowed. Issue error and
15506 warning messages under control of COMPLAIN. */
15509 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
15511 if (INTEGRAL_TYPE_P (type
))
15513 else if (POINTER_TYPE_P (type
))
15515 else if (TYPE_PTR_TO_MEMBER_P (type
))
15517 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
15519 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
15522 if (complain
& tf_error
)
15523 error ("%q#T is not a valid type for a template constant parameter", type
);
15527 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
15528 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
15531 dependent_type_p_r (tree type
)
15537 A type is dependent if it is:
15539 -- a template parameter. Template template parameters are types
15540 for us (since TYPE_P holds true for them) so we handle
15542 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
15543 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
15545 /* -- a qualified-id with a nested-name-specifier which contains a
15546 class-name that names a dependent type or whose unqualified-id
15547 names a dependent type. */
15548 if (TREE_CODE (type
) == TYPENAME_TYPE
)
15550 /* -- a cv-qualified type where the cv-unqualified type is
15552 type
= TYPE_MAIN_VARIANT (type
);
15553 /* -- a compound type constructed from any dependent type. */
15554 if (TYPE_PTR_TO_MEMBER_P (type
))
15555 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
15556 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
15558 else if (TREE_CODE (type
) == POINTER_TYPE
15559 || TREE_CODE (type
) == REFERENCE_TYPE
)
15560 return dependent_type_p (TREE_TYPE (type
));
15561 else if (TREE_CODE (type
) == FUNCTION_TYPE
15562 || TREE_CODE (type
) == METHOD_TYPE
)
15566 if (dependent_type_p (TREE_TYPE (type
)))
15568 for (arg_type
= TYPE_ARG_TYPES (type
);
15570 arg_type
= TREE_CHAIN (arg_type
))
15571 if (dependent_type_p (TREE_VALUE (arg_type
)))
15575 /* -- an array type constructed from any dependent type or whose
15576 size is specified by a constant expression that is
15577 value-dependent. */
15578 if (TREE_CODE (type
) == ARRAY_TYPE
)
15580 if (TYPE_DOMAIN (type
)
15581 && dependent_type_p (TYPE_DOMAIN (type
)))
15583 return dependent_type_p (TREE_TYPE (type
));
15585 else if (TREE_CODE (type
) == INTEGER_TYPE
15586 && !TREE_CONSTANT (TYPE_MAX_VALUE (type
)))
15588 /* If this is the TYPE_DOMAIN of an array type, consider it
15590 return (value_dependent_expression_p (TYPE_MAX_VALUE (type
))
15591 || type_dependent_expression_p (TYPE_MAX_VALUE (type
)));
15594 /* -- a template-id in which either the template name is a template
15596 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
15598 /* ... or any of the template arguments is a dependent type or
15599 an expression that is type-dependent or value-dependent. */
15600 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
15601 && (any_dependent_template_arguments_p
15602 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
15605 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
15606 argument of the `typeof' expression is not type-dependent, then
15607 it should already been have resolved. */
15608 if (TREE_CODE (type
) == TYPEOF_TYPE
15609 || TREE_CODE (type
) == DECLTYPE_TYPE
)
15612 /* A template argument pack is dependent if any of its packed
15614 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
15616 tree args
= ARGUMENT_PACK_ARGS (type
);
15617 int i
, len
= TREE_VEC_LENGTH (args
);
15618 for (i
= 0; i
< len
; ++i
)
15619 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
15623 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
15624 be template parameters. */
15625 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
15628 /* The standard does not specifically mention types that are local
15629 to template functions or local classes, but they should be
15630 considered dependent too. For example:
15632 template <int I> void f() {
15637 The size of `E' cannot be known until the value of `I' has been
15638 determined. Therefore, `E' must be considered dependent. */
15639 scope
= TYPE_CONTEXT (type
);
15640 if (scope
&& TYPE_P (scope
))
15641 return dependent_type_p (scope
);
15642 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15643 return type_dependent_expression_p (scope
);
15645 /* Other types are non-dependent. */
15649 /* Returns TRUE if TYPE is dependent, in the sense of
15650 [temp.dep.type]. */
15653 dependent_type_p (tree type
)
15655 /* If there are no template parameters in scope, then there can't be
15656 any dependent types. */
15657 if (!processing_template_decl
)
15659 /* If we are not processing a template, then nobody should be
15660 providing us with a dependent type. */
15662 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
);
15666 /* If the type is NULL, we have not computed a type for the entity
15667 in question; in that case, the type is dependent. */
15671 /* Erroneous types can be considered non-dependent. */
15672 if (type
== error_mark_node
)
15675 /* If we have not already computed the appropriate value for TYPE,
15677 if (!TYPE_DEPENDENT_P_VALID (type
))
15679 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
15680 TYPE_DEPENDENT_P_VALID (type
) = 1;
15683 return TYPE_DEPENDENT_P (type
);
15686 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
15689 dependent_scope_ref_p (tree expression
, bool criterion (tree
))
15694 gcc_assert (TREE_CODE (expression
) == SCOPE_REF
);
15696 if (!TYPE_P (TREE_OPERAND (expression
, 0)))
15699 scope
= TREE_OPERAND (expression
, 0);
15700 name
= TREE_OPERAND (expression
, 1);
15704 An id-expression is type-dependent if it contains a
15705 nested-name-specifier that contains a class-name that names a
15707 /* The suggested resolution to Core Issue 2 implies that if the
15708 qualifying type is the current class, then we must peek
15711 && currently_open_class (scope
)
15712 && !criterion (name
))
15714 if (dependent_type_p (scope
))
15720 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15721 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15725 value_dependent_expression_p (tree expression
)
15727 if (!processing_template_decl
)
15730 /* A name declared with a dependent type. */
15731 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
15734 switch (TREE_CODE (expression
))
15736 case IDENTIFIER_NODE
:
15737 /* A name that has not been looked up -- must be dependent. */
15740 case TEMPLATE_PARM_INDEX
:
15741 /* A non-type template parm. */
15745 /* A non-type template parm. */
15746 if (DECL_TEMPLATE_PARM_P (expression
))
15748 return value_dependent_expression_p (DECL_INITIAL (expression
));
15751 /* A constant with integral or enumeration type and is initialized
15752 with an expression that is value-dependent. */
15753 if (DECL_INITIAL (expression
)
15754 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression
))
15755 && value_dependent_expression_p (DECL_INITIAL (expression
)))
15759 case DYNAMIC_CAST_EXPR
:
15760 case STATIC_CAST_EXPR
:
15761 case CONST_CAST_EXPR
:
15762 case REINTERPRET_CAST_EXPR
:
15764 /* These expressions are value-dependent if the type to which
15765 the cast occurs is dependent or the expression being casted
15766 is value-dependent. */
15768 tree type
= TREE_TYPE (expression
);
15770 if (dependent_type_p (type
))
15773 /* A functional cast has a list of operands. */
15774 expression
= TREE_OPERAND (expression
, 0);
15777 /* If there are no operands, it must be an expression such
15778 as "int()". This should not happen for aggregate types
15779 because it would form non-constant expressions. */
15780 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
15785 if (TREE_CODE (expression
) == TREE_LIST
)
15786 return any_value_dependent_elements_p (expression
);
15788 return value_dependent_expression_p (expression
);
15793 /* A `sizeof' expression is value-dependent if the operand is
15794 type-dependent or is a pack expansion. */
15795 expression
= TREE_OPERAND (expression
, 0);
15796 if (PACK_EXPANSION_P (expression
))
15798 else if (TYPE_P (expression
))
15799 return dependent_type_p (expression
);
15800 return type_dependent_expression_p (expression
);
15803 return dependent_scope_ref_p (expression
, value_dependent_expression_p
);
15805 case COMPONENT_REF
:
15806 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
15807 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
15810 /* A CALL_EXPR may appear in a constant expression if it is a
15811 call to a builtin function, e.g., __builtin_constant_p. All
15812 such calls are value-dependent. */
15815 case NONTYPE_ARGUMENT_PACK
:
15816 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15817 is value-dependent. */
15819 tree values
= ARGUMENT_PACK_ARGS (expression
);
15820 int i
, len
= TREE_VEC_LENGTH (values
);
15822 for (i
= 0; i
< len
; ++i
)
15823 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
15831 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
15832 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
15833 || (type2
? dependent_type_p (type2
) : false));
15837 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
15838 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
15841 /* A constant expression is value-dependent if any subexpression is
15842 value-dependent. */
15843 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
15845 case tcc_reference
:
15847 return (value_dependent_expression_p
15848 (TREE_OPERAND (expression
, 0)));
15850 case tcc_comparison
:
15852 return ((value_dependent_expression_p
15853 (TREE_OPERAND (expression
, 0)))
15854 || (value_dependent_expression_p
15855 (TREE_OPERAND (expression
, 1))));
15857 case tcc_expression
:
15861 for (i
= 0; i
< TREE_OPERAND_LENGTH (expression
); ++i
)
15862 /* In some cases, some of the operands may be missing.
15863 (For example, in the case of PREDECREMENT_EXPR, the
15864 amount to increment by may be missing.) That doesn't
15865 make the expression dependent. */
15866 if (TREE_OPERAND (expression
, i
)
15867 && (value_dependent_expression_p
15868 (TREE_OPERAND (expression
, i
))))
15878 /* The expression is not value-dependent. */
15882 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15883 [temp.dep.expr]. */
15886 type_dependent_expression_p (tree expression
)
15888 if (!processing_template_decl
)
15891 if (expression
== error_mark_node
)
15894 /* An unresolved name is always dependent. */
15895 if (TREE_CODE (expression
) == IDENTIFIER_NODE
15896 || TREE_CODE (expression
) == USING_DECL
)
15899 /* Some expression forms are never type-dependent. */
15900 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
15901 || TREE_CODE (expression
) == SIZEOF_EXPR
15902 || TREE_CODE (expression
) == ALIGNOF_EXPR
15903 || TREE_CODE (expression
) == TRAIT_EXPR
15904 || TREE_CODE (expression
) == TYPEID_EXPR
15905 || TREE_CODE (expression
) == DELETE_EXPR
15906 || TREE_CODE (expression
) == VEC_DELETE_EXPR
15907 || TREE_CODE (expression
) == THROW_EXPR
)
15910 /* The types of these expressions depends only on the type to which
15911 the cast occurs. */
15912 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
15913 || TREE_CODE (expression
) == STATIC_CAST_EXPR
15914 || TREE_CODE (expression
) == CONST_CAST_EXPR
15915 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
15916 || TREE_CODE (expression
) == CAST_EXPR
)
15917 return dependent_type_p (TREE_TYPE (expression
));
15919 /* The types of these expressions depends only on the type created
15920 by the expression. */
15921 if (TREE_CODE (expression
) == NEW_EXPR
15922 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
15924 /* For NEW_EXPR tree nodes created inside a template, either
15925 the object type itself or a TREE_LIST may appear as the
15927 tree type
= TREE_OPERAND (expression
, 1);
15928 if (TREE_CODE (type
) == TREE_LIST
)
15929 /* This is an array type. We need to check array dimensions
15931 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
15932 || value_dependent_expression_p
15933 (TREE_OPERAND (TREE_VALUE (type
), 1));
15935 return dependent_type_p (type
);
15938 if (TREE_CODE (expression
) == SCOPE_REF
15939 && dependent_scope_ref_p (expression
,
15940 type_dependent_expression_p
))
15943 if (TREE_CODE (expression
) == FUNCTION_DECL
15944 && DECL_LANG_SPECIFIC (expression
)
15945 && DECL_TEMPLATE_INFO (expression
)
15946 && (any_dependent_template_arguments_p
15947 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
15950 if (TREE_CODE (expression
) == TEMPLATE_DECL
15951 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
15954 if (TREE_CODE (expression
) == STMT_EXPR
)
15955 expression
= stmt_expr_value_expr (expression
);
15957 if (TREE_TYPE (expression
) == unknown_type_node
)
15959 if (TREE_CODE (expression
) == ADDR_EXPR
)
15960 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
15961 if (TREE_CODE (expression
) == COMPONENT_REF
15962 || TREE_CODE (expression
) == OFFSET_REF
)
15964 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
15966 expression
= TREE_OPERAND (expression
, 1);
15967 if (TREE_CODE (expression
) == IDENTIFIER_NODE
)
15970 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15971 if (TREE_CODE (expression
) == SCOPE_REF
)
15974 if (TREE_CODE (expression
) == BASELINK
)
15975 expression
= BASELINK_FUNCTIONS (expression
);
15977 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
15979 if (any_dependent_template_arguments_p
15980 (TREE_OPERAND (expression
, 1)))
15982 expression
= TREE_OPERAND (expression
, 0);
15984 gcc_assert (TREE_CODE (expression
) == OVERLOAD
15985 || TREE_CODE (expression
) == FUNCTION_DECL
);
15989 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
15991 expression
= OVL_NEXT (expression
);
15996 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
15998 return (dependent_type_p (TREE_TYPE (expression
)));
16001 /* Like type_dependent_expression_p, but it also works while not processing
16002 a template definition, i.e. during substitution or mangling. */
16005 type_dependent_expression_p_push (tree expr
)
16008 ++processing_template_decl
;
16009 b
= type_dependent_expression_p (expr
);
16010 --processing_template_decl
;
16014 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
16015 contains a type-dependent expression. */
16018 any_type_dependent_arguments_p (const_tree args
)
16022 tree arg
= TREE_VALUE (args
);
16024 if (type_dependent_expression_p (arg
))
16026 args
= TREE_CHAIN (args
);
16031 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
16032 expressions) contains any value-dependent expressions. */
16035 any_value_dependent_elements_p (const_tree list
)
16037 for (; list
; list
= TREE_CHAIN (list
))
16038 if (value_dependent_expression_p (TREE_VALUE (list
)))
16044 /* Returns TRUE if the ARG (a template argument) is dependent. */
16047 dependent_template_arg_p (tree arg
)
16049 if (!processing_template_decl
)
16052 if (TREE_CODE (arg
) == TEMPLATE_DECL
16053 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
16054 return dependent_template_p (arg
);
16055 else if (ARGUMENT_PACK_P (arg
))
16057 tree args
= ARGUMENT_PACK_ARGS (arg
);
16058 int i
, len
= TREE_VEC_LENGTH (args
);
16059 for (i
= 0; i
< len
; ++i
)
16061 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
16067 else if (TYPE_P (arg
))
16068 return dependent_type_p (arg
);
16070 return (type_dependent_expression_p (arg
)
16071 || value_dependent_expression_p (arg
));
16074 /* Returns true if ARGS (a collection of template arguments) contains
16075 any types that require structural equality testing. */
16078 any_template_arguments_need_structural_equality_p (tree args
)
16085 if (args
== error_mark_node
)
16088 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
16090 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
16091 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
16093 tree arg
= TREE_VEC_ELT (level
, j
);
16094 tree packed_args
= NULL_TREE
;
16097 if (ARGUMENT_PACK_P (arg
))
16099 /* Look inside the argument pack. */
16100 packed_args
= ARGUMENT_PACK_ARGS (arg
);
16101 len
= TREE_VEC_LENGTH (packed_args
);
16104 for (k
= 0; k
< len
; ++k
)
16107 arg
= TREE_VEC_ELT (packed_args
, k
);
16109 if (error_operand_p (arg
))
16111 else if (TREE_CODE (arg
) == TEMPLATE_DECL
16112 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
16114 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
16116 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
16117 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
16126 /* Returns true if ARGS (a collection of template arguments) contains
16127 any dependent arguments. */
16130 any_dependent_template_arguments_p (const_tree args
)
16137 if (args
== error_mark_node
)
16140 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
16142 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
16143 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
16144 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
16151 /* Returns TRUE if the template TMPL is dependent. */
16154 dependent_template_p (tree tmpl
)
16156 if (TREE_CODE (tmpl
) == OVERLOAD
)
16160 if (dependent_template_p (OVL_FUNCTION (tmpl
)))
16162 tmpl
= OVL_CHAIN (tmpl
);
16167 /* Template template parameters are dependent. */
16168 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
16169 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
16171 /* So are names that have not been looked up. */
16172 if (TREE_CODE (tmpl
) == SCOPE_REF
16173 || TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
16175 /* So are member templates of dependent classes. */
16176 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
16177 return dependent_type_p (DECL_CONTEXT (tmpl
));
16181 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
16184 dependent_template_id_p (tree tmpl
, tree args
)
16186 return (dependent_template_p (tmpl
)
16187 || any_dependent_template_arguments_p (args
));
16190 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
16191 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
16192 no such TYPE can be found. Note that this function peers inside
16193 uninstantiated templates and therefore should be used only in
16194 extremely limited situations. ONLY_CURRENT_P restricts this
16195 peering to the currently open classes hierarchy (which is required
16196 when comparing types). */
16199 resolve_typename_type (tree type
, bool only_current_p
)
16208 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
16210 scope
= TYPE_CONTEXT (type
);
16211 name
= TYPE_IDENTIFIER (type
);
16213 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
16214 it first before we can figure out what NAME refers to. */
16215 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
16216 scope
= resolve_typename_type (scope
, only_current_p
);
16217 /* If we don't know what SCOPE refers to, then we cannot resolve the
16219 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
16221 /* If the SCOPE is a template type parameter, we have no way of
16222 resolving the name. */
16223 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
16225 /* If the SCOPE is not the current instantiation, there's no reason
16226 to look inside it. */
16227 if (only_current_p
&& !currently_open_class (scope
))
16229 /* If SCOPE isn't the template itself, it will not have a valid
16230 TYPE_FIELDS list. */
16231 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
16232 /* scope is either the template itself or a compatible instantiation
16233 like X<T>, so look up the name in the original template. */
16234 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
16236 /* scope is a partial instantiation, so we can't do the lookup or we
16237 will lose the template arguments. */
16239 /* Enter the SCOPE so that name lookup will be resolved as if we
16240 were in the class definition. In particular, SCOPE will no
16241 longer be considered a dependent type. */
16242 pushed_scope
= push_scope (scope
);
16243 /* Look up the declaration. */
16244 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true);
16246 result
= NULL_TREE
;
16248 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
16249 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
16252 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == IDENTIFIER_NODE
16253 && TREE_CODE (decl
) == TYPE_DECL
)
16255 result
= TREE_TYPE (decl
);
16256 if (result
== error_mark_node
)
16257 result
= NULL_TREE
;
16259 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
16260 && DECL_CLASS_TEMPLATE_P (decl
))
16264 /* Obtain the template and the arguments. */
16265 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
16266 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
16267 /* Instantiate the template. */
16268 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
16269 /*entering_scope=*/0,
16270 tf_error
| tf_user
);
16271 if (result
== error_mark_node
)
16272 result
= NULL_TREE
;
16275 /* Leave the SCOPE. */
16277 pop_scope (pushed_scope
);
16279 /* If we failed to resolve it, return the original typename. */
16283 /* If lookup found a typename type, resolve that too. */
16284 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
16286 /* Ill-formed programs can cause infinite recursion here, so we
16287 must catch that. */
16288 TYPENAME_IS_RESOLVING_P (type
) = 1;
16289 result
= resolve_typename_type (result
, only_current_p
);
16290 TYPENAME_IS_RESOLVING_P (type
) = 0;
16293 /* Qualify the resulting type. */
16294 quals
= cp_type_quals (type
);
16296 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
16301 /* EXPR is an expression which is not type-dependent. Return a proxy
16302 for EXPR that can be used to compute the types of larger
16303 expressions containing EXPR. */
16306 build_non_dependent_expr (tree expr
)
16310 /* Preserve null pointer constants so that the type of things like
16311 "p == 0" where "p" is a pointer can be determined. */
16312 if (null_ptr_cst_p (expr
))
16314 /* Preserve OVERLOADs; the functions must be available to resolve
16317 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
16318 inner_expr
= stmt_expr_value_expr (inner_expr
);
16319 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
16320 inner_expr
= TREE_OPERAND (inner_expr
, 0);
16321 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
16322 inner_expr
= TREE_OPERAND (inner_expr
, 1);
16323 if (is_overloaded_fn (inner_expr
)
16324 || TREE_CODE (inner_expr
) == OFFSET_REF
)
16326 /* There is no need to return a proxy for a variable. */
16327 if (TREE_CODE (expr
) == VAR_DECL
)
16329 /* Preserve string constants; conversions from string constants to
16330 "char *" are allowed, even though normally a "const char *"
16331 cannot be used to initialize a "char *". */
16332 if (TREE_CODE (expr
) == STRING_CST
)
16334 /* Preserve arithmetic constants, as an optimization -- there is no
16335 reason to create a new node. */
16336 if (TREE_CODE (expr
) == INTEGER_CST
|| TREE_CODE (expr
) == REAL_CST
)
16338 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
16339 There is at least one place where we want to know that a
16340 particular expression is a throw-expression: when checking a ?:
16341 expression, there are special rules if the second or third
16342 argument is a throw-expression. */
16343 if (TREE_CODE (expr
) == THROW_EXPR
)
16346 if (TREE_CODE (expr
) == COND_EXPR
)
16347 return build3 (COND_EXPR
,
16349 TREE_OPERAND (expr
, 0),
16350 (TREE_OPERAND (expr
, 1)
16351 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
16352 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
16353 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
16354 if (TREE_CODE (expr
) == COMPOUND_EXPR
16355 && !COMPOUND_EXPR_OVERLOADED (expr
))
16356 return build2 (COMPOUND_EXPR
,
16358 TREE_OPERAND (expr
, 0),
16359 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
16361 /* If the type is unknown, it can't really be non-dependent */
16362 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
16364 /* Otherwise, build a NON_DEPENDENT_EXPR.
16366 REFERENCE_TYPEs are not stripped for expressions in templates
16367 because doing so would play havoc with mangling. Consider, for
16370 template <typename T> void f<T& g>() { g(); }
16372 In the body of "f", the expression for "g" will have
16373 REFERENCE_TYPE, even though the standard says that it should
16374 not. The reason is that we must preserve the syntactic form of
16375 the expression so that mangling (say) "f<g>" inside the body of
16376 "f" works out correctly. Therefore, the REFERENCE_TYPE is
16378 return build1 (NON_DEPENDENT_EXPR
, non_reference (TREE_TYPE (expr
)), expr
);
16381 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
16382 Return a new TREE_LIST with the various arguments replaced with
16383 equivalent non-dependent expressions. */
16386 build_non_dependent_args (tree args
)
16391 new_args
= NULL_TREE
;
16392 for (a
= args
; a
; a
= TREE_CHAIN (a
))
16393 new_args
= tree_cons (NULL_TREE
,
16394 build_non_dependent_expr (TREE_VALUE (a
)),
16396 return nreverse (new_args
);
16399 #include "gt-cp-pt.h"