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 (MAYBE_CLASS_TYPE_P (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
&& !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
= cxx_make_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
= cxx_make_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 /* [temp.arg.nontype]/5, bullet 5
4561 For a non-type template-parameter of type reference to function, no
4562 conversions apply. If the template-argument represents a set of
4563 overloaded functions, the matching function is selected from the set
4565 else if (TYPE_REFFN_P (type
))
4567 if (TREE_CODE (expr
) == ADDR_EXPR
)
4569 error ("%qE is not a valid template argument for type %qT "
4570 "because it is a pointer", expr
, type
);
4571 inform ("try using %qE instead", TREE_OPERAND (expr
, 0));
4575 expr
= convert_nontype_argument_function (TREE_TYPE (type
), expr
);
4576 if (!expr
|| expr
== error_mark_node
)
4579 expr
= build_nop (type
, build_address (expr
));
4581 /* [temp.arg.nontype]/5, bullet 6
4583 For a non-type template-parameter of type pointer to member function,
4584 no conversions apply. If the template-argument represents a set of
4585 overloaded member functions, the matching member function is selected
4586 from the set (_over.over_). */
4587 else if (TYPE_PTRMEMFUNC_P (type
))
4589 expr
= instantiate_type (type
, expr
, tf_none
);
4590 if (expr
== error_mark_node
)
4591 return error_mark_node
;
4593 /* There is no way to disable standard conversions in
4594 resolve_address_of_overloaded_function (called by
4595 instantiate_type). It is possible that the call succeeded by
4596 converting &B::I to &D::I (where B is a base of D), so we need
4597 to reject this conversion here.
4599 Actually, even if there was a way to disable standard conversions,
4600 it would still be better to reject them here so that we can
4601 provide a superior diagnostic. */
4602 if (!same_type_p (TREE_TYPE (expr
), type
))
4604 /* Make sure we are just one standard conversion off. */
4605 gcc_assert (can_convert (type
, TREE_TYPE (expr
)));
4606 error ("%qE is not a valid template argument for type %qT "
4607 "because it is of type %qT", expr
, type
,
4609 inform ("standard conversions are not allowed in this context");
4613 /* [temp.arg.nontype]/5, bullet 7
4615 For a non-type template-parameter of type pointer to data member,
4616 qualification conversions (_conv.qual_) are applied. */
4617 else if (TYPE_PTRMEM_P (type
))
4619 expr
= perform_qualification_conversions (type
, expr
);
4620 if (expr
== error_mark_node
)
4623 /* A template non-type parameter must be one of the above. */
4627 /* Sanity check: did we actually convert the argument to the
4629 gcc_assert (same_type_p (type
, TREE_TYPE (expr
)));
4633 /* Subroutine of coerce_template_template_parms, which returns 1 if
4634 PARM_PARM and ARG_PARM match using the rule for the template
4635 parameters of template template parameters. Both PARM and ARG are
4636 template parameters; the rest of the arguments are the same as for
4637 coerce_template_template_parms.
4640 coerce_template_template_parm (tree parm
,
4642 tsubst_flags_t complain
,
4646 if (arg
== NULL_TREE
|| arg
== error_mark_node
4647 || parm
== NULL_TREE
|| parm
== error_mark_node
)
4650 if (TREE_CODE (arg
) != TREE_CODE (parm
))
4653 switch (TREE_CODE (parm
))
4656 /* We encounter instantiations of templates like
4657 template <template <template <class> class> class TT>
4660 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
4661 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
4663 if (!coerce_template_template_parms
4664 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
4670 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
4671 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
4672 /* Argument is a parameter pack but parameter is not. */
4677 /* The tsubst call is used to handle cases such as
4679 template <int> class C {};
4680 template <class T, template <T> class TT> class D {};
4683 i.e. the parameter list of TT depends on earlier parameters. */
4684 if (!dependent_type_p (TREE_TYPE (arg
))
4686 (tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
),
4690 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
4691 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
4692 /* Argument is a parameter pack but parameter is not. */
4705 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4706 template template parameters. Both PARM_PARMS and ARG_PARMS are
4707 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4710 Consider the example:
4711 template <class T> class A;
4712 template<template <class U> class TT> class B;
4714 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4715 the parameters to A, and OUTER_ARGS contains A. */
4718 coerce_template_template_parms (tree parm_parms
,
4720 tsubst_flags_t complain
,
4724 int nparms
, nargs
, i
;
4728 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
4729 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
4731 nparms
= TREE_VEC_LENGTH (parm_parms
);
4732 nargs
= TREE_VEC_LENGTH (arg_parms
);
4734 /* Determine whether we have a parameter pack at the end of the
4735 template template parameter's template parameter list. */
4736 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
4738 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
4740 switch (TREE_CODE (parm
))
4744 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
4749 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
4759 && !(variadic_p
&& nargs
>= nparms
- 1))
4762 /* Check all of the template parameters except the parameter pack at
4763 the end (if any). */
4764 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
4766 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
4767 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
4770 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
4771 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
4773 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
4781 /* Check each of the template parameters in the template
4782 argument against the template parameter pack at the end of
4783 the template template parameter. */
4784 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
4787 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
4789 for (; i
< nargs
; ++i
)
4791 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
4794 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
4796 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
4805 /* Verifies that the deduced template arguments (in TARGS) for the
4806 template template parameters (in TPARMS) represent valid bindings,
4807 by comparing the template parameter list of each template argument
4808 to the template parameter list of its corresponding template
4809 template parameter, in accordance with DR150. This
4810 routine can only be called after all template arguments have been
4811 deduced. It will return TRUE if all of the template template
4812 parameter bindings are okay, FALSE otherwise. */
4814 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
4816 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
4818 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
4820 for (i
= 0; i
< ntparms
; ++i
)
4822 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
4823 tree targ
= TREE_VEC_ELT (targs
, i
);
4825 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
4827 tree packed_args
= NULL_TREE
;
4830 if (ARGUMENT_PACK_P (targ
))
4832 /* Look inside the argument pack. */
4833 packed_args
= ARGUMENT_PACK_ARGS (targ
);
4834 len
= TREE_VEC_LENGTH (packed_args
);
4837 for (idx
= 0; idx
< len
; ++idx
)
4839 tree targ_parms
= NULL_TREE
;
4842 /* Extract the next argument from the argument
4844 targ
= TREE_VEC_ELT (packed_args
, idx
);
4846 if (PACK_EXPANSION_P (targ
))
4847 /* Look at the pattern of the pack expansion. */
4848 targ
= PACK_EXPANSION_PATTERN (targ
);
4850 /* Extract the template parameters from the template
4852 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
4853 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
4854 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
4855 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
4857 /* Verify that we can coerce the template template
4858 parameters from the template argument to the template
4859 parameter. This requires an exact match. */
4861 && !coerce_template_template_parms
4862 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
4872 /* Everything is okay. */
4876 /* Convert the indicated template ARG as necessary to match the
4877 indicated template PARM. Returns the converted ARG, or
4878 error_mark_node if the conversion was unsuccessful. Error and
4879 warning messages are issued under control of COMPLAIN. This
4880 conversion is for the Ith parameter in the parameter list. ARGS is
4881 the full set of template arguments deduced so far. */
4884 convert_template_argument (tree parm
,
4887 tsubst_flags_t complain
,
4893 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
4895 if (TREE_CODE (arg
) == TREE_LIST
4896 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
4898 /* The template argument was the name of some
4899 member function. That's usually
4900 invalid, but static members are OK. In any
4901 case, grab the underlying fields/functions
4902 and issue an error later if required. */
4903 orig_arg
= TREE_VALUE (arg
);
4904 TREE_TYPE (arg
) = unknown_type_node
;
4909 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
4910 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
4911 || requires_tmpl_type
);
4913 /* When determining whether an argument pack expansion is a template,
4914 look at the pattern. */
4915 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
4916 arg
= PACK_EXPANSION_PATTERN (arg
);
4919 ((TREE_CODE (arg
) == TEMPLATE_DECL
4920 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
4921 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4922 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
4925 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
4926 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
4927 arg
= TYPE_STUB_DECL (arg
);
4929 is_type
= TYPE_P (arg
) || is_tmpl_type
;
4931 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
4932 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
4934 pedwarn ("to refer to a type member of a template parameter, "
4935 "use %<typename %E%>", orig_arg
);
4937 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
4938 TREE_OPERAND (arg
, 1),
4940 complain
& tf_error
);
4944 if (is_type
!= requires_type
)
4948 if (complain
& tf_error
)
4950 error ("type/value mismatch at argument %d in template "
4951 "parameter list for %qD",
4954 error (" expected a constant of type %qT, got %qT",
4956 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
4957 else if (requires_tmpl_type
)
4958 error (" expected a class template, got %qE", orig_arg
);
4960 error (" expected a type, got %qE", orig_arg
);
4963 return error_mark_node
;
4965 if (is_tmpl_type
^ requires_tmpl_type
)
4967 if (in_decl
&& (complain
& tf_error
))
4969 error ("type/value mismatch at argument %d in template "
4970 "parameter list for %qD",
4973 error (" expected a type, got %qT", DECL_NAME (arg
));
4975 error (" expected a class template, got %qT", orig_arg
);
4977 return error_mark_node
;
4982 if (requires_tmpl_type
)
4984 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
4985 /* The number of argument required is not known yet.
4986 Just accept it for now. */
4987 val
= TREE_TYPE (arg
);
4990 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
4993 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
4995 if (coerce_template_template_parms (parmparm
, argparm
,
5001 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5003 if (val
!= error_mark_node
)
5005 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
5006 val
= TREE_TYPE (val
);
5007 else if (TREE_CODE (val
) == TYPE_PACK_EXPANSION
5008 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg
))
5010 val
= TREE_TYPE (arg
);
5011 val
= make_pack_expansion (val
);
5017 if (in_decl
&& (complain
& tf_error
))
5019 error ("type/value mismatch at argument %d in "
5020 "template parameter list for %qD",
5022 error (" expected a template of type %qD, got %qD",
5026 val
= error_mark_node
;
5032 /* We only form one instance of each template specialization.
5033 Therefore, if we use a non-canonical variant (i.e., a
5034 typedef), any future messages referring to the type will use
5035 the typedef, which is confusing if those future uses do not
5036 themselves also use the typedef. */
5038 val
= canonical_type_variant (val
);
5042 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
5044 if (invalid_nontype_parm_type_p (t
, complain
))
5045 return error_mark_node
;
5047 if (!uses_template_parms (orig_arg
) && !uses_template_parms (t
))
5048 /* We used to call digest_init here. However, digest_init
5049 will report errors, which we don't want when complain
5050 is zero. More importantly, digest_init will try too
5051 hard to convert things: for example, `0' should not be
5052 converted to pointer type at this point according to
5053 the standard. Accepting this is not merely an
5054 extension, since deciding whether or not these
5055 conversions can occur is part of determining which
5056 function template to call, or whether a given explicit
5057 argument specification is valid. */
5058 val
= convert_nontype_argument (t
, orig_arg
);
5062 if (val
== NULL_TREE
)
5063 val
= error_mark_node
;
5064 else if (val
== error_mark_node
&& (complain
& tf_error
))
5065 error ("could not convert template argument %qE to %qT", orig_arg
, t
);
5071 /* Coerces the remaining template arguments in INNER_ARGS (from
5072 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5073 Returns the coerced argument pack. PARM_IDX is the position of this
5074 parameter in the template parameter list. ARGS is the original
5075 template argument list. */
5077 coerce_template_parameter_pack (tree parms
,
5085 tsubst_flags_t complain
)
5087 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
5088 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
5091 tree packed_types
= NULL_TREE
;
5093 if (arg_idx
> nargs
)
5096 packed_args
= make_tree_vec (nargs
- arg_idx
);
5098 if (TREE_CODE (TREE_VALUE (parm
)) == PARM_DECL
5099 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm
))))
5101 /* When the template parameter is a non-type template
5102 parameter pack whose type uses parameter packs, we need
5103 to look at each of the template arguments
5104 separately. Build a vector of the types for these
5105 non-type template parameters in PACKED_TYPES. */
5107 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm
)));
5108 packed_types
= tsubst_pack_expansion (expansion
, args
,
5111 if (packed_types
== error_mark_node
)
5112 return error_mark_node
;
5114 /* Check that we have the right number of arguments. */
5116 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
))
5117 && nargs
- arg_idx
!= TREE_VEC_LENGTH (packed_types
))
5120 = TREE_VEC_LENGTH (parms
) - 1 + TREE_VEC_LENGTH (packed_types
);
5121 error ("wrong number of template arguments (%d, should be %d)",
5122 nargs
, needed_parms
);
5123 return error_mark_node
;
5126 /* If we aren't able to check the actual arguments now
5127 (because they haven't been expanded yet), we can at least
5128 verify that all of the types used for the non-type
5129 template parameter pack are, in fact, valid for non-type
5130 template parameters. */
5132 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
5134 int j
, len
= TREE_VEC_LENGTH (packed_types
);
5135 for (j
= 0; j
< len
; ++j
)
5137 tree t
= TREE_VEC_ELT (packed_types
, j
);
5138 if (invalid_nontype_parm_type_p (t
, complain
))
5139 return error_mark_node
;
5144 /* Convert the remaining arguments, which will be a part of the
5145 parameter pack "parm". */
5146 for (; arg_idx
< nargs
; ++arg_idx
)
5148 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
5149 tree actual_parm
= TREE_VALUE (parm
);
5151 if (packed_types
&& !PACK_EXPANSION_P (arg
))
5153 /* When we have a vector of types (corresponding to the
5154 non-type template parameter pack that uses parameter
5155 packs in its type, as mention above), and the
5156 argument is not an expansion (which expands to a
5157 currently unknown number of arguments), clone the
5158 parm and give it the next type in PACKED_TYPES. */
5159 actual_parm
= copy_node (actual_parm
);
5160 TREE_TYPE (actual_parm
) =
5161 TREE_VEC_ELT (packed_types
, arg_idx
- parm_idx
);
5164 if (arg
!= error_mark_node
)
5165 arg
= convert_template_argument (actual_parm
,
5166 arg
, new_args
, complain
, parm_idx
,
5168 if (arg
== error_mark_node
)
5170 TREE_VEC_ELT (packed_args
, arg_idx
- parm_idx
) = arg
;
5173 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
5174 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
5175 argument_pack
= make_node (TYPE_ARGUMENT_PACK
);
5178 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
5179 TREE_TYPE (argument_pack
)
5180 = tsubst (TREE_TYPE (TREE_VALUE (parm
)), new_args
, complain
, in_decl
);
5181 TREE_CONSTANT (argument_pack
) = 1;
5184 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
5185 return argument_pack
;
5188 /* Convert all template arguments to their appropriate types, and
5189 return a vector containing the innermost resulting template
5190 arguments. If any error occurs, return error_mark_node. Error and
5191 warning messages are issued under control of COMPLAIN.
5193 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5194 for arguments not specified in ARGS. Otherwise, if
5195 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5196 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5197 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5201 coerce_template_parms (tree parms
,
5204 tsubst_flags_t complain
,
5205 bool require_all_args
,
5206 bool use_default_args
)
5208 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
5211 tree new_inner_args
;
5212 bool saved_skip_evaluation
;
5214 /* When used as a boolean value, indicates whether this is a
5215 variadic template parameter list. Since it's an int, we can also
5216 subtract it from nparms to get the number of non-variadic
5221 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args
));
5223 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
5224 nparms
= TREE_VEC_LENGTH (parms
);
5226 /* Determine if there are any parameter packs. */
5227 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
5229 tree tparm
= TREE_VALUE (TREE_VEC_ELT (parms
, parm_idx
));
5230 if (template_parameter_pack_p (tparm
))
5237 if ((nargs
> nparms
- variadic_p
&& !variadic_p
)
5238 || (nargs
< nparms
- variadic_p
5240 && (!use_default_args
5241 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
5242 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
5244 if (complain
& tf_error
)
5246 const char *or_more
= "";
5249 or_more
= " or more";
5253 error ("wrong number of template arguments (%d, should be %d%s)",
5254 nargs
, nparms
, or_more
);
5257 error ("provided for %q+D", in_decl
);
5260 return error_mark_node
;
5263 /* We need to evaluate the template arguments, even though this
5264 template-id may be nested within a "sizeof". */
5265 saved_skip_evaluation
= skip_evaluation
;
5266 skip_evaluation
= false;
5267 new_inner_args
= make_tree_vec (nparms
);
5268 new_args
= add_outermost_template_args (args
, new_inner_args
);
5269 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
5274 /* Get the Ith template parameter. */
5275 parm
= TREE_VEC_ELT (parms
, parm_idx
);
5277 if (parm
== error_mark_node
)
5279 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
5283 /* Calculate the next argument. */
5284 if (template_parameter_pack_p (TREE_VALUE (parm
)))
5286 /* All remaining arguments will be placed in the
5287 template parameter pack PARM. */
5288 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
5289 inner_args
, arg_idx
,
5293 /* Store this argument. */
5294 if (arg
== error_mark_node
)
5296 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
5298 /* We are done with all of the arguments. */
5303 else if (arg_idx
< nargs
)
5305 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
5307 if (arg
&& PACK_EXPANSION_P (arg
))
5309 if (complain
& tf_error
)
5311 /* If ARG is a pack expansion, but PARM is not a
5312 template parameter pack (if it were, we would have
5313 handled it above), we're trying to expand into a
5314 fixed-length argument list. */
5315 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
5316 error ("cannot expand %<%E%> into a fixed-length "
5317 "argument list", arg
);
5319 error ("cannot expand %<%T%> into a fixed-length "
5320 "argument list", arg
);
5322 return error_mark_node
;
5325 else if (require_all_args
)
5326 /* There must be a default arg in this case. */
5327 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
5332 if (arg
== error_mark_node
)
5334 if (complain
& tf_error
)
5335 error ("template argument %d is invalid", arg_idx
+ 1);
5338 /* This only occurs if there was an error in the template
5339 parameter list itself (which we would already have
5340 reported) that we are trying to recover from, e.g., a class
5341 template with a parameter list such as
5342 template<typename..., typename>. */
5343 return error_mark_node
;
5345 arg
= convert_template_argument (TREE_VALUE (parm
),
5346 arg
, new_args
, complain
,
5349 if (arg
== error_mark_node
)
5351 TREE_VEC_ELT (new_inner_args
, arg_idx
) = arg
;
5353 skip_evaluation
= saved_skip_evaluation
;
5356 return error_mark_node
;
5358 return new_inner_args
;
5361 /* Returns 1 if template args OT and NT are equivalent. */
5364 template_args_equal (tree ot
, tree nt
)
5369 if (TREE_CODE (nt
) == TREE_VEC
)
5370 /* For member templates */
5371 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
5372 else if (PACK_EXPANSION_P (ot
))
5373 return PACK_EXPANSION_P (nt
)
5374 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
5375 PACK_EXPANSION_PATTERN (nt
));
5376 else if (TYPE_P (nt
))
5377 return TYPE_P (ot
) && same_type_p (ot
, nt
);
5378 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
5381 return cp_tree_equal (ot
, nt
);
5384 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5385 of template arguments. Returns 0 otherwise. */
5388 comp_template_args (tree oldargs
, tree newargs
)
5392 oldargs
= expand_template_argument_pack (oldargs
);
5393 newargs
= expand_template_argument_pack (newargs
);
5395 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
5398 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
5400 tree nt
= TREE_VEC_ELT (newargs
, i
);
5401 tree ot
= TREE_VEC_ELT (oldargs
, i
);
5403 if (! template_args_equal (ot
, nt
))
5410 add_pending_template (tree d
)
5412 tree ti
= (TYPE_P (d
)
5413 ? CLASSTYPE_TEMPLATE_INFO (d
)
5414 : DECL_TEMPLATE_INFO (d
));
5415 struct pending_template
*pt
;
5418 if (TI_PENDING_TEMPLATE_FLAG (ti
))
5421 /* We are called both from instantiate_decl, where we've already had a
5422 tinst_level pushed, and instantiate_template, where we haven't.
5424 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
5427 push_tinst_level (d
);
5429 pt
= GGC_NEW (struct pending_template
);
5431 pt
->tinst
= current_tinst_level
;
5432 if (last_pending_template
)
5433 last_pending_template
->next
= pt
;
5435 pending_templates
= pt
;
5437 last_pending_template
= pt
;
5439 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
5446 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5447 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5448 documentation for TEMPLATE_ID_EXPR. */
5451 lookup_template_function (tree fns
, tree arglist
)
5455 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
5456 return error_mark_node
;
5458 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
5459 gcc_assert (fns
&& (is_overloaded_fn (fns
)
5460 || TREE_CODE (fns
) == IDENTIFIER_NODE
));
5462 if (BASELINK_P (fns
))
5464 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
5466 BASELINK_FUNCTIONS (fns
),
5471 type
= TREE_TYPE (fns
);
5472 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
5473 type
= unknown_type_node
;
5475 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
5478 /* Within the scope of a template class S<T>, the name S gets bound
5479 (in build_self_reference) to a TYPE_DECL for the class, not a
5480 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5481 or one of its enclosing classes, and that type is a template,
5482 return the associated TEMPLATE_DECL. Otherwise, the original
5483 DECL is returned. */
5486 maybe_get_template_decl_from_type_decl (tree decl
)
5488 return (decl
!= NULL_TREE
5489 && TREE_CODE (decl
) == TYPE_DECL
5490 && DECL_ARTIFICIAL (decl
)
5491 && CLASS_TYPE_P (TREE_TYPE (decl
))
5492 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
5493 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
5496 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5497 parameters, find the desired type.
5499 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5501 IN_DECL, if non-NULL, is the template declaration we are trying to
5504 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5505 the class we are looking up.
5507 Issue error and warning messages under control of COMPLAIN.
5509 If the template class is really a local class in a template
5510 function, then the FUNCTION_CONTEXT is the function in which it is
5513 ??? Note that this function is currently called *twice* for each
5514 template-id: the first time from the parser, while creating the
5515 incomplete type (finish_template_type), and the second type during the
5516 real instantiation (instantiate_template_class). This is surely something
5517 that we want to avoid. It also causes some problems with argument
5518 coercion (see convert_nontype_argument for more information on this). */
5521 lookup_template_class (tree d1
,
5526 tsubst_flags_t complain
)
5528 tree
template = NULL_TREE
, parmlist
;
5531 timevar_push (TV_NAME_LOOKUP
);
5533 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
5535 tree value
= innermost_non_namespace_value (d1
);
5536 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
5541 push_decl_namespace (context
);
5542 template = lookup_name (d1
);
5543 template = maybe_get_template_decl_from_type_decl (template);
5545 pop_decl_namespace ();
5548 context
= DECL_CONTEXT (template);
5550 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
5552 tree type
= TREE_TYPE (d1
);
5554 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5555 an implicit typename for the second A. Deal with it. */
5556 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5557 type
= TREE_TYPE (type
);
5559 if (CLASSTYPE_TEMPLATE_INFO (type
))
5561 template = CLASSTYPE_TI_TEMPLATE (type
);
5562 d1
= DECL_NAME (template);
5565 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
5566 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
5568 template = TYPE_TI_TEMPLATE (d1
);
5569 d1
= DECL_NAME (template);
5571 else if (TREE_CODE (d1
) == TEMPLATE_DECL
5572 && TREE_CODE (DECL_TEMPLATE_RESULT (d1
)) == TYPE_DECL
)
5575 d1
= DECL_NAME (template);
5576 context
= DECL_CONTEXT (template);
5579 /* Issue an error message if we didn't find a template. */
5582 if (complain
& tf_error
)
5583 error ("%qT is not a template", d1
);
5584 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5587 if (TREE_CODE (template) != TEMPLATE_DECL
5588 /* Make sure it's a user visible template, if it was named by
5590 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (template)
5591 && !PRIMARY_TEMPLATE_P (template)))
5593 if (complain
& tf_error
)
5595 error ("non-template type %qT used as a template", d1
);
5597 error ("for template declaration %q+D", in_decl
);
5599 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5602 complain
&= ~tf_user
;
5604 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
5606 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5607 template arguments */
5613 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
5615 /* Consider an example where a template template parameter declared as
5617 template <class T, class U = std::allocator<T> > class TT
5619 The template parameter level of T and U are one level larger than
5620 of TT. To proper process the default argument of U, say when an
5621 instantiation `TT<int>' is seen, we need to build the full
5622 arguments containing {int} as the innermost level. Outer levels,
5623 available when not appearing as default template argument, can be
5624 obtained from the arguments of the enclosing template.
5626 Suppose that TT is later substituted with std::vector. The above
5627 instantiation is `TT<int, std::allocator<T> >' with TT at
5628 level 1, and T at level 2, while the template arguments at level 1
5629 becomes {std::vector} and the inner level 2 is {int}. */
5631 outer
= DECL_CONTEXT (template);
5633 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
5634 else if (current_template_parms
)
5635 /* This is an argument of the current template, so we haven't set
5636 DECL_CONTEXT yet. */
5637 outer
= current_template_args ();
5640 arglist
= add_to_template_args (outer
, arglist
);
5642 arglist2
= coerce_template_parms (parmlist
, arglist
, template,
5644 /*require_all_args=*/true,
5645 /*use_default_args=*/true);
5646 if (arglist2
== error_mark_node
5647 || (!uses_template_parms (arglist2
)
5648 && check_instantiated_args (template, arglist2
, complain
)))
5649 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5651 parm
= bind_template_template_parm (TREE_TYPE (template), arglist2
);
5652 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, parm
);
5656 tree template_type
= TREE_TYPE (template);
5659 tree found
= NULL_TREE
;
5662 int is_partial_instantiation
;
5664 gen_tmpl
= most_general_template (template);
5665 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
5666 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
5667 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
5669 if (arg_depth
== 1 && parm_depth
> 1)
5671 /* We've been given an incomplete set of template arguments.
5674 template <class T> struct S1 {
5675 template <class U> struct S2 {};
5676 template <class U> struct S2<U*> {};
5679 we will be called with an ARGLIST of `U*', but the
5680 TEMPLATE will be `template <class T> template
5681 <class U> struct S1<T>::S2'. We must fill in the missing
5684 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
5686 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
5689 /* Now we should have enough arguments. */
5690 gcc_assert (parm_depth
== arg_depth
);
5692 /* From here on, we're only interested in the most general
5694 template = gen_tmpl
;
5696 /* Calculate the BOUND_ARGS. These will be the args that are
5697 actually tsubst'd into the definition to create the
5701 /* We have multiple levels of arguments to coerce, at once. */
5703 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
5705 tree bound_args
= make_tree_vec (parm_depth
);
5707 for (i
= saved_depth
,
5708 t
= DECL_TEMPLATE_PARMS (template);
5709 i
> 0 && t
!= NULL_TREE
;
5710 --i
, t
= TREE_CHAIN (t
))
5712 tree a
= coerce_template_parms (TREE_VALUE (t
),
5715 /*require_all_args=*/true,
5716 /*use_default_args=*/true);
5718 /* Don't process further if one of the levels fails. */
5719 if (a
== error_mark_node
)
5721 /* Restore the ARGLIST to its full size. */
5722 TREE_VEC_LENGTH (arglist
) = saved_depth
;
5723 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5726 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
5728 /* We temporarily reduce the length of the ARGLIST so
5729 that coerce_template_parms will see only the arguments
5730 corresponding to the template parameters it is
5732 TREE_VEC_LENGTH (arglist
)--;
5735 /* Restore the ARGLIST to its full size. */
5736 TREE_VEC_LENGTH (arglist
) = saved_depth
;
5738 arglist
= bound_args
;
5742 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
5743 INNERMOST_TEMPLATE_ARGS (arglist
),
5746 /*require_all_args=*/true,
5747 /*use_default_args=*/true);
5749 if (arglist
== error_mark_node
)
5750 /* We were unable to bind the arguments. */
5751 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5753 /* In the scope of a template class, explicit references to the
5754 template class refer to the type of the template, not any
5755 instantiation of it. For example, in:
5757 template <class T> class C { void f(C<T>); }
5759 the `C<T>' is just the same as `C'. Outside of the
5760 class, however, such a reference is an instantiation. */
5761 if (comp_template_args (TYPE_TI_ARGS (template_type
),
5764 found
= template_type
;
5766 if (!entering_scope
&& PRIMARY_TEMPLATE_P (template))
5770 for (ctx
= current_class_type
;
5771 ctx
&& TREE_CODE (ctx
) != NAMESPACE_DECL
;
5773 ? TYPE_CONTEXT (ctx
)
5774 : DECL_CONTEXT (ctx
)))
5775 if (TYPE_P (ctx
) && same_type_p (ctx
, template_type
))
5778 /* We're not in the scope of the class, so the
5779 TEMPLATE_TYPE is not the type we want after all. */
5785 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5787 /* If we already have this specialization, return it. */
5788 found
= retrieve_specialization (template, arglist
,
5789 /*class_specializations_p=*/false);
5791 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5793 /* This type is a "partial instantiation" if any of the template
5794 arguments still involve template parameters. Note that we set
5795 IS_PARTIAL_INSTANTIATION for partial specializations as
5797 is_partial_instantiation
= uses_template_parms (arglist
);
5799 /* If the deduced arguments are invalid, then the binding
5801 if (!is_partial_instantiation
5802 && check_instantiated_args (template,
5803 INNERMOST_TEMPLATE_ARGS (arglist
),
5805 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
5807 if (!is_partial_instantiation
5808 && !PRIMARY_TEMPLATE_P (template)
5809 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL
)
5811 found
= xref_tag_from_type (TREE_TYPE (template),
5812 DECL_NAME (template),
5813 /*tag_scope=*/ts_global
);
5814 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, found
);
5817 context
= tsubst (DECL_CONTEXT (template), arglist
,
5820 context
= global_namespace
;
5822 /* Create the type. */
5823 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
5825 if (!is_partial_instantiation
)
5827 set_current_access_from_decl (TYPE_NAME (template_type
));
5828 t
= start_enum (TYPE_IDENTIFIER (template_type
));
5831 /* We don't want to call start_enum for this type, since
5832 the values for the enumeration constants may involve
5833 template parameters. And, no one should be interested
5834 in the enumeration constants for such a type. */
5835 t
= make_node (ENUMERAL_TYPE
);
5839 t
= make_class_type (TREE_CODE (template_type
));
5840 CLASSTYPE_DECLARED_CLASS (t
)
5841 = CLASSTYPE_DECLARED_CLASS (template_type
);
5842 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
5843 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
5845 /* A local class. Make sure the decl gets registered properly. */
5846 if (context
== current_function_decl
)
5847 pushtag (DECL_NAME (template), t
, /*tag_scope=*/ts_current
);
5849 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
5850 /* This instantiation is another name for the primary
5851 template type. Set the TYPE_CANONICAL field
5853 TYPE_CANONICAL (t
) = template_type
;
5854 else if (any_template_arguments_need_structural_equality_p (arglist
))
5855 /* Some of the template arguments require structural
5856 equality testing, so this template class requires
5857 structural equality testing. */
5858 SET_TYPE_STRUCTURAL_EQUALITY (t
);
5861 /* If we called start_enum or pushtag above, this information
5862 will already be set up. */
5865 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5867 type_decl
= create_implicit_typedef (DECL_NAME (template), t
);
5868 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
5869 TYPE_STUB_DECL (t
) = type_decl
;
5870 DECL_SOURCE_LOCATION (type_decl
)
5871 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
5874 type_decl
= TYPE_NAME (t
);
5876 TREE_PRIVATE (type_decl
)
5877 = TREE_PRIVATE (TYPE_STUB_DECL (template_type
));
5878 TREE_PROTECTED (type_decl
)
5879 = TREE_PROTECTED (TYPE_STUB_DECL (template_type
));
5880 DECL_IN_SYSTEM_HEADER (type_decl
)
5881 = DECL_IN_SYSTEM_HEADER (template);
5882 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
5884 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
5885 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
5888 /* Set up the template information. We have to figure out which
5889 template is the immediate parent if this is a full
5891 if (parm_depth
== 1 || is_partial_instantiation
5892 || !PRIMARY_TEMPLATE_P (template))
5893 /* This case is easy; there are no member templates involved. */
5897 /* This is a full instantiation of a member template. Look
5898 for a partial instantiation of which this is an instance. */
5900 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
5901 found
; found
= TREE_CHAIN (found
))
5904 tree tmpl
= CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found
));
5906 /* We only want partial instantiations, here, not
5907 specializations or full instantiations. */
5908 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found
))
5909 || !uses_template_parms (TREE_VALUE (found
)))
5912 /* Temporarily reduce by one the number of levels in the
5913 ARGLIST and in FOUND so as to avoid comparing the
5914 last set of arguments. */
5915 TREE_VEC_LENGTH (arglist
)--;
5916 TREE_VEC_LENGTH (TREE_PURPOSE (found
)) --;
5918 /* See if the arguments match. If they do, then TMPL is
5919 the partial instantiation we want. */
5920 success
= comp_template_args (TREE_PURPOSE (found
), arglist
);
5922 /* Restore the argument vectors to their full size. */
5923 TREE_VEC_LENGTH (arglist
)++;
5924 TREE_VEC_LENGTH (TREE_PURPOSE (found
))++;
5935 /* There was no partial instantiation. This happens
5936 where C<T> is a member template of A<T> and it's used
5939 template <typename T> struct B { A<T>::C<int> m; };
5942 Create the partial instantiation.
5944 TREE_VEC_LENGTH (arglist
)--;
5945 found
= tsubst (template, arglist
, complain
, NULL_TREE
);
5946 TREE_VEC_LENGTH (arglist
)++;
5950 SET_TYPE_TEMPLATE_INFO (t
, tree_cons (found
, arglist
, NULL_TREE
));
5951 DECL_TEMPLATE_INSTANTIATIONS (template)
5952 = tree_cons (arglist
, t
,
5953 DECL_TEMPLATE_INSTANTIATIONS (template));
5955 if (TREE_CODE (t
) == ENUMERAL_TYPE
5956 && !is_partial_instantiation
)
5957 /* Now that the type has been registered on the instantiations
5958 list, we set up the enumerators. Because the enumeration
5959 constants may involve the enumeration type itself, we make
5960 sure to register the type first, and then create the
5961 constants. That way, doing tsubst_expr for the enumeration
5962 constants won't result in recursive calls here; we'll find
5963 the instantiation and exit above. */
5964 tsubst_enum (template_type
, t
, arglist
);
5966 if (is_partial_instantiation
)
5967 /* If the type makes use of template parameters, the
5968 code that generates debugging information will crash. */
5969 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
5971 /* Possibly limit visibility based on template args. */
5972 TREE_PUBLIC (type_decl
) = 1;
5973 determine_visibility (type_decl
);
5975 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
5977 timevar_pop (TV_NAME_LOOKUP
);
5984 /* True when we should also visit template parameters that occur in
5985 non-deduced contexts. */
5986 bool include_nondeduced_p
;
5987 struct pointer_set_t
*visited
;
5990 /* Called from for_each_template_parm via walk_tree. */
5993 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
5996 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
5997 tree_fn_t fn
= pfd
->fn
;
5998 void *data
= pfd
->data
;
6001 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
)
6002 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
, pfd
->visited
,
6003 pfd
->include_nondeduced_p
))
6004 return error_mark_node
;
6006 switch (TREE_CODE (t
))
6009 if (TYPE_PTRMEMFUNC_P (t
))
6015 if (!TYPE_TEMPLATE_INFO (t
))
6017 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t
)),
6018 fn
, data
, pfd
->visited
,
6019 pfd
->include_nondeduced_p
))
6020 return error_mark_node
;
6024 if (for_each_template_parm (TYPE_MIN_VALUE (t
),
6025 fn
, data
, pfd
->visited
,
6026 pfd
->include_nondeduced_p
)
6027 || for_each_template_parm (TYPE_MAX_VALUE (t
),
6028 fn
, data
, pfd
->visited
,
6029 pfd
->include_nondeduced_p
))
6030 return error_mark_node
;
6034 /* Since we're not going to walk subtrees, we have to do this
6036 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
,
6037 pfd
->visited
, pfd
->include_nondeduced_p
))
6038 return error_mark_node
;
6042 /* Check the return type. */
6043 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
6044 pfd
->include_nondeduced_p
))
6045 return error_mark_node
;
6047 /* Check the parameter types. Since default arguments are not
6048 instantiated until they are needed, the TYPE_ARG_TYPES may
6049 contain expressions that involve template parameters. But,
6050 no-one should be looking at them yet. And, once they're
6051 instantiated, they don't contain template parameters, so
6052 there's no point in looking at them then, either. */
6056 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
6057 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
,
6058 pfd
->visited
, pfd
->include_nondeduced_p
))
6059 return error_mark_node
;
6061 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6062 want walk_tree walking into them itself. */
6068 if (pfd
->include_nondeduced_p
6069 && for_each_template_parm (TYPE_FIELDS (t
), fn
, data
,
6071 pfd
->include_nondeduced_p
))
6072 return error_mark_node
;
6077 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
6078 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
,
6079 pfd
->visited
, pfd
->include_nondeduced_p
))
6080 return error_mark_node
;
6085 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
)
6086 && for_each_template_parm (DECL_INITIAL (t
), fn
, data
,
6087 pfd
->visited
, pfd
->include_nondeduced_p
))
6088 return error_mark_node
;
6089 if (DECL_CONTEXT (t
)
6090 && pfd
->include_nondeduced_p
6091 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
,
6092 pfd
->visited
, pfd
->include_nondeduced_p
))
6093 return error_mark_node
;
6096 case BOUND_TEMPLATE_TEMPLATE_PARM
:
6097 /* Record template parameters such as `T' inside `TT<T>'. */
6098 if (for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
, pfd
->visited
,
6099 pfd
->include_nondeduced_p
))
6100 return error_mark_node
;
6103 case TEMPLATE_TEMPLATE_PARM
:
6104 case TEMPLATE_TYPE_PARM
:
6105 case TEMPLATE_PARM_INDEX
:
6106 if (fn
&& (*fn
)(t
, data
))
6107 return error_mark_node
;
6109 return error_mark_node
;
6113 /* A template template parameter is encountered. */
6114 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
6115 && for_each_template_parm (TREE_TYPE (t
), fn
, data
, pfd
->visited
,
6116 pfd
->include_nondeduced_p
))
6117 return error_mark_node
;
6119 /* Already substituted template template parameter */
6125 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
,
6127 pfd
->include_nondeduced_p
))
6128 return error_mark_node
;
6132 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
6133 && pfd
->include_nondeduced_p
6134 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6135 (TREE_TYPE (t
)), fn
, data
,
6136 pfd
->visited
, pfd
->include_nondeduced_p
))
6137 return error_mark_node
;
6142 /* If there's no type, then this thing must be some expression
6143 involving template parameters. */
6144 if (!fn
&& !TREE_TYPE (t
))
6145 return error_mark_node
;
6150 case REINTERPRET_CAST_EXPR
:
6151 case CONST_CAST_EXPR
:
6152 case STATIC_CAST_EXPR
:
6153 case DYNAMIC_CAST_EXPR
:
6157 case PSEUDO_DTOR_EXPR
:
6159 return error_mark_node
;
6166 /* We didn't find any template parameters we liked. */
6170 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6171 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6172 call FN with the parameter and the DATA.
6173 If FN returns nonzero, the iteration is terminated, and
6174 for_each_template_parm returns 1. Otherwise, the iteration
6175 continues. If FN never returns a nonzero value, the value
6176 returned by for_each_template_parm is 0. If FN is NULL, it is
6177 considered to be the function which always returns 1.
6179 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6180 parameters that occur in non-deduced contexts. When false, only
6181 visits those template parameters that can be deduced. */
6184 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
6185 struct pointer_set_t
*visited
,
6186 bool include_nondeduced_p
)
6188 struct pair_fn_data pfd
;
6194 pfd
.include_nondeduced_p
= include_nondeduced_p
;
6196 /* Walk the tree. (Conceptually, we would like to walk without
6197 duplicates, but for_each_template_parm_r recursively calls
6198 for_each_template_parm, so we would need to reorganize a fair
6199 bit to use walk_tree_without_duplicates, so we keep our own
6202 pfd
.visited
= visited
;
6204 pfd
.visited
= pointer_set_create ();
6205 result
= cp_walk_tree (&t
,
6206 for_each_template_parm_r
,
6208 pfd
.visited
) != NULL_TREE
;
6213 pointer_set_destroy (pfd
.visited
);
6220 /* Returns true if T depends on any template parameter. */
6223 uses_template_parms (tree t
)
6226 int saved_processing_template_decl
;
6228 saved_processing_template_decl
= processing_template_decl
;
6229 if (!saved_processing_template_decl
)
6230 processing_template_decl
= 1;
6232 dependent_p
= dependent_type_p (t
);
6233 else if (TREE_CODE (t
) == TREE_VEC
)
6234 dependent_p
= any_dependent_template_arguments_p (t
);
6235 else if (TREE_CODE (t
) == TREE_LIST
)
6236 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
6237 || uses_template_parms (TREE_CHAIN (t
)));
6238 else if (TREE_CODE (t
) == TYPE_DECL
)
6239 dependent_p
= dependent_type_p (TREE_TYPE (t
));
6242 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
6243 || TREE_CODE (t
) == OVERLOAD
6244 || TREE_CODE (t
) == BASELINK
6245 || TREE_CODE (t
) == IDENTIFIER_NODE
6246 || TREE_CODE (t
) == TRAIT_EXPR
6247 || CONSTANT_CLASS_P (t
))
6248 dependent_p
= (type_dependent_expression_p (t
)
6249 || value_dependent_expression_p (t
));
6252 gcc_assert (t
== error_mark_node
);
6253 dependent_p
= false;
6256 processing_template_decl
= saved_processing_template_decl
;
6261 /* Returns true if T depends on any template parameter with level LEVEL. */
6264 uses_template_parms_level (tree t
, int level
)
6266 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
6267 /*include_nondeduced_p=*/true);
6270 static int tinst_depth
;
6271 extern int max_tinst_depth
;
6272 #ifdef GATHER_STATISTICS
6275 static int tinst_level_tick
;
6276 static int last_template_error_tick
;
6278 /* We're starting to instantiate D; record the template instantiation context
6279 for diagnostics and to restore it later. */
6282 push_tinst_level (tree d
)
6284 struct tinst_level
*new;
6286 if (tinst_depth
>= max_tinst_depth
)
6288 /* If the instantiation in question still has unbound template parms,
6289 we don't really care if we can't instantiate it, so just return.
6290 This happens with base instantiation for implicit `typename'. */
6291 if (uses_template_parms (d
))
6294 last_template_error_tick
= tinst_level_tick
;
6295 error ("template instantiation depth exceeds maximum of %d (use "
6296 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6297 max_tinst_depth
, d
);
6299 print_instantiation_context ();
6304 new = GGC_NEW (struct tinst_level
);
6306 new->locus
= input_location
;
6307 new->in_system_header_p
= in_system_header
;
6308 new->next
= current_tinst_level
;
6309 current_tinst_level
= new;
6312 #ifdef GATHER_STATISTICS
6313 if (tinst_depth
> depth_reached
)
6314 depth_reached
= tinst_depth
;
6321 /* We're done instantiating this template; return to the instantiation
6325 pop_tinst_level (void)
6327 /* Restore the filename and line number stashed away when we started
6328 this instantiation. */
6329 input_location
= current_tinst_level
->locus
;
6330 in_system_header
= current_tinst_level
->in_system_header_p
;
6331 current_tinst_level
= current_tinst_level
->next
;
6336 /* We're instantiating a deferred template; restore the template
6337 instantiation context in which the instantiation was requested, which
6338 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6341 reopen_tinst_level (struct tinst_level
*level
)
6343 struct tinst_level
*t
;
6346 for (t
= level
; t
; t
= t
->next
)
6349 current_tinst_level
= level
;
6354 /* Returns the TINST_LEVEL which gives the original instantiation
6357 struct tinst_level
*
6358 outermost_tinst_level (void)
6360 struct tinst_level
*level
= current_tinst_level
;
6363 level
= level
->next
;
6367 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6368 vector of template arguments, as for tsubst.
6370 Returns an appropriate tsubst'd friend declaration. */
6373 tsubst_friend_function (tree decl
, tree args
)
6377 if (TREE_CODE (decl
) == FUNCTION_DECL
6378 && DECL_TEMPLATE_INSTANTIATION (decl
)
6379 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
6380 /* This was a friend declared with an explicit template
6381 argument list, e.g.:
6385 to indicate that f was a template instantiation, not a new
6386 function declaration. Now, we have to figure out what
6387 instantiation of what template. */
6389 tree template_id
, arglist
, fns
;
6392 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
6394 /* Friend functions are looked up in the containing namespace scope.
6395 We must enter that scope, to avoid finding member functions of the
6396 current cless with same name. */
6397 push_nested_namespace (ns
);
6398 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
6399 tf_warning_or_error
, NULL_TREE
,
6400 /*integral_constant_expression_p=*/false);
6401 pop_nested_namespace (ns
);
6402 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
6403 tf_warning_or_error
, NULL_TREE
);
6404 template_id
= lookup_template_function (fns
, arglist
);
6406 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
6407 tmpl
= determine_specialization (template_id
, new_friend
,
6409 /*need_member_template=*/0,
6410 TREE_VEC_LENGTH (args
),
6412 return instantiate_template (tmpl
, new_args
, tf_error
);
6415 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
6417 /* The NEW_FRIEND will look like an instantiation, to the
6418 compiler, but is not an instantiation from the point of view of
6419 the language. For example, we might have had:
6421 template <class T> struct S {
6422 template <class U> friend void f(T, U);
6425 Then, in S<int>, template <class U> void f(int, U) is not an
6426 instantiation of anything. */
6427 if (new_friend
== error_mark_node
)
6428 return error_mark_node
;
6430 DECL_USE_TEMPLATE (new_friend
) = 0;
6431 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
6433 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
6434 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
6435 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
6438 /* The mangled name for the NEW_FRIEND is incorrect. The function
6439 is not a template instantiation and should not be mangled like
6440 one. Therefore, we forget the mangling here; we'll recompute it
6441 later if we need it. */
6442 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
6444 SET_DECL_RTL (new_friend
, NULL_RTX
);
6445 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
6448 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
6451 tree new_friend_template_info
;
6452 tree new_friend_result_template_info
;
6454 int new_friend_is_defn
;
6456 /* We must save some information from NEW_FRIEND before calling
6457 duplicate decls since that function will free NEW_FRIEND if
6459 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
6460 new_friend_is_defn
=
6461 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6462 (template_for_substitution (new_friend
)))
6464 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
6466 /* This declaration is a `primary' template. */
6467 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
6469 new_friend_result_template_info
6470 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
6473 new_friend_result_template_info
= NULL_TREE
;
6475 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6476 if (new_friend_is_defn
)
6477 DECL_INITIAL (new_friend
) = error_mark_node
;
6479 /* Inside pushdecl_namespace_level, we will push into the
6480 current namespace. However, the friend function should go
6481 into the namespace of the template. */
6482 ns
= decl_namespace_context (new_friend
);
6483 push_nested_namespace (ns
);
6484 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
6485 pop_nested_namespace (ns
);
6487 if (old_decl
== error_mark_node
)
6488 return error_mark_node
;
6490 if (old_decl
!= new_friend
)
6492 /* This new friend declaration matched an existing
6493 declaration. For example, given:
6495 template <class T> void f(T);
6496 template <class U> class C {
6497 template <class T> friend void f(T) {}
6500 the friend declaration actually provides the definition
6501 of `f', once C has been instantiated for some type. So,
6502 old_decl will be the out-of-class template declaration,
6503 while new_friend is the in-class definition.
6505 But, if `f' was called before this point, the
6506 instantiation of `f' will have DECL_TI_ARGS corresponding
6507 to `T' but not to `U', references to which might appear
6508 in the definition of `f'. Previously, the most general
6509 template for an instantiation of `f' was the out-of-class
6510 version; now it is the in-class version. Therefore, we
6511 run through all specialization of `f', adding to their
6512 DECL_TI_ARGS appropriately. In particular, they need a
6513 new set of outer arguments, corresponding to the
6514 arguments for this class instantiation.
6516 The same situation can arise with something like this:
6519 template <class T> class C {
6523 when `C<int>' is instantiated. Now, `f(int)' is defined
6526 if (!new_friend_is_defn
)
6527 /* On the other hand, if the in-class declaration does
6528 *not* provide a definition, then we don't want to alter
6529 existing definitions. We can just leave everything
6534 /* Overwrite whatever template info was there before, if
6535 any, with the new template information pertaining to
6537 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
6539 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
6540 reregister_specialization (new_friend
,
6541 most_general_template (old_decl
),
6546 tree new_friend_args
;
6548 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
6549 = new_friend_result_template_info
;
6551 new_friend_args
= TI_ARGS (new_friend_template_info
);
6552 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (old_decl
);
6556 tree spec
= TREE_VALUE (t
);
6559 = add_outermost_template_args (new_friend_args
,
6560 DECL_TI_ARGS (spec
));
6563 /* Now, since specializations are always supposed to
6564 hang off of the most general template, we must move
6566 t
= most_general_template (old_decl
);
6569 DECL_TEMPLATE_SPECIALIZATIONS (t
)
6570 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t
),
6571 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
));
6572 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
) = NULL_TREE
;
6577 /* The information from NEW_FRIEND has been merged into OLD_DECL
6578 by duplicate_decls. */
6579 new_friend
= old_decl
;
6584 tree context
= DECL_CONTEXT (new_friend
);
6588 template <class T> class C {
6589 template <class U> friend void C1<U>::f (); // case 1
6590 friend void C2<T>::f (); // case 2
6592 we only need to make sure CONTEXT is a complete type for
6593 case 2. To distinguish between the two cases, we note that
6594 CONTEXT of case 1 remains dependent type after tsubst while
6595 this isn't true for case 2. */
6596 ++processing_template_decl
;
6597 dependent_p
= dependent_type_p (context
);
6598 --processing_template_decl
;
6601 && !complete_type_or_else (context
, NULL_TREE
))
6602 return error_mark_node
;
6604 if (COMPLETE_TYPE_P (context
))
6606 /* Check to see that the declaration is really present, and,
6607 possibly obtain an improved declaration. */
6608 tree fn
= check_classfn (context
,
6609 new_friend
, NULL_TREE
);
6619 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6620 template arguments, as for tsubst.
6622 Returns an appropriate tsubst'd friend type or error_mark_node on
6626 tsubst_friend_class (tree friend_tmpl
, tree args
)
6632 context
= DECL_CONTEXT (friend_tmpl
);
6636 if (TREE_CODE (context
) == NAMESPACE_DECL
)
6637 push_nested_namespace (context
);
6639 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
6642 /* Look for a class template declaration. We look for hidden names
6643 because two friend declarations of the same template are the
6644 same. For example, in:
6647 template <typename> friend class F;
6649 template <typename> struct B {
6650 template <typename> friend class F;
6653 both F templates are the same. */
6654 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
6655 /*block_p=*/true, 0,
6656 LOOKUP_COMPLAIN
| LOOKUP_HIDDEN
);
6658 /* But, if we don't find one, it might be because we're in a
6659 situation like this:
6667 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6668 for `S<int>', not the TEMPLATE_DECL. */
6669 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
6671 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
6672 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
6675 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
6677 /* The friend template has already been declared. Just
6678 check to see that the declarations match, and install any new
6679 default parameters. We must tsubst the default parameters,
6680 of course. We only need the innermost template parameters
6681 because that is all that redeclare_class_template will look
6683 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
6684 > TMPL_ARGS_DEPTH (args
))
6687 location_t saved_input_location
;
6688 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
6689 args
, tf_warning_or_error
);
6691 saved_input_location
= input_location
;
6692 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
6693 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
6694 input_location
= saved_input_location
;
6698 friend_type
= TREE_TYPE (tmpl
);
6702 /* The friend template has not already been declared. In this
6703 case, the instantiation of the template class will cause the
6704 injection of this template into the global scope. */
6705 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
6706 if (tmpl
== error_mark_node
)
6707 return error_mark_node
;
6709 /* The new TMPL is not an instantiation of anything, so we
6710 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6711 the new type because that is supposed to be the corresponding
6712 template decl, i.e., TMPL. */
6713 DECL_USE_TEMPLATE (tmpl
) = 0;
6714 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
6715 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
6716 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
6717 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
6719 /* Inject this template into the global scope. */
6720 friend_type
= TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl
, true));
6725 if (TREE_CODE (context
) == NAMESPACE_DECL
)
6726 pop_nested_namespace (context
);
6728 pop_nested_class ();
6734 /* Returns zero if TYPE cannot be completed later due to circularity.
6735 Otherwise returns one. */
6738 can_complete_type_without_circularity (tree type
)
6740 if (type
== NULL_TREE
|| type
== error_mark_node
)
6742 else if (COMPLETE_TYPE_P (type
))
6744 else if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
6745 return can_complete_type_without_circularity (TREE_TYPE (type
));
6746 else if (CLASS_TYPE_P (type
)
6747 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
6753 /* Apply any attributes which had to be deferred until instantiation
6754 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6755 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6758 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
6759 tree args
, tsubst_flags_t complain
, tree in_decl
)
6761 tree last_dep
= NULL_TREE
;
6765 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
6766 if (ATTR_IS_DEPENDENT (t
))
6769 attributes
= copy_list (attributes
);
6773 if (DECL_P (*decl_p
))
6775 if (TREE_TYPE (*decl_p
) == error_mark_node
)
6777 p
= &DECL_ATTRIBUTES (*decl_p
);
6780 p
= &TYPE_ATTRIBUTES (*decl_p
);
6784 tree late_attrs
= NULL_TREE
;
6785 tree
*q
= &late_attrs
;
6787 for (*p
= attributes
; *p
; )
6790 if (ATTR_IS_DEPENDENT (t
))
6792 *p
= TREE_CHAIN (t
);
6793 TREE_CHAIN (t
) = NULL_TREE
;
6794 /* If the first attribute argument is an identifier, don't
6795 pass it through tsubst. Attributes like mode, format,
6796 cleanup and several target specific attributes expect it
6799 && TREE_CODE (TREE_VALUE (t
)) == TREE_LIST
6800 && TREE_VALUE (TREE_VALUE (t
))
6801 && (TREE_CODE (TREE_VALUE (TREE_VALUE (t
)))
6802 == IDENTIFIER_NODE
))
6805 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t
)), args
, complain
,
6807 /*integral_constant_expression_p=*/false);
6808 if (chain
!= TREE_CHAIN (TREE_VALUE (t
)))
6810 = tree_cons (NULL_TREE
, TREE_VALUE (TREE_VALUE (t
)),
6815 = tsubst_expr (TREE_VALUE (t
), args
, complain
, in_decl
,
6816 /*integral_constant_expression_p=*/false);
6818 q
= &TREE_CHAIN (t
);
6821 p
= &TREE_CHAIN (t
);
6824 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
6829 instantiate_class_template (tree type
)
6831 tree
template, args
, pattern
, t
, member
;
6836 if (type
== error_mark_node
)
6837 return error_mark_node
;
6839 if (TYPE_BEING_DEFINED (type
)
6840 || COMPLETE_TYPE_P (type
)
6841 || dependent_type_p (type
))
6844 /* Figure out which template is being instantiated. */
6845 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
6846 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL
);
6848 /* Determine what specialization of the original template to
6850 t
= most_specialized_class (type
, template);
6851 if (t
== error_mark_node
)
6853 TYPE_BEING_DEFINED (type
) = 1;
6854 return error_mark_node
;
6858 /* This TYPE is actually an instantiation of a partial
6859 specialization. We replace the innermost set of ARGS with
6860 the arguments appropriate for substitution. For example,
6863 template <class T> struct S {};
6864 template <class T> struct S<T*> {};
6866 and supposing that we are instantiating S<int*>, ARGS will
6867 presently be {int*} -- but we need {int}. */
6868 pattern
= TREE_TYPE (t
);
6869 args
= TREE_PURPOSE (t
);
6873 pattern
= TREE_TYPE (template);
6874 args
= CLASSTYPE_TI_ARGS (type
);
6877 /* If the template we're instantiating is incomplete, then clearly
6878 there's nothing we can do. */
6879 if (!COMPLETE_TYPE_P (pattern
))
6882 /* If we've recursively instantiated too many templates, stop. */
6883 if (! push_tinst_level (type
))
6886 /* Now we're really doing the instantiation. Mark the type as in
6887 the process of being defined. */
6888 TYPE_BEING_DEFINED (type
) = 1;
6890 /* We may be in the middle of deferred access check. Disable
6892 push_deferring_access_checks (dk_no_deferred
);
6894 push_to_top_level ();
6896 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
6898 /* Set the input location to the template definition. This is needed
6899 if tsubsting causes an error. */
6900 typedecl
= TYPE_MAIN_DECL (type
);
6901 input_location
= DECL_SOURCE_LOCATION (typedecl
);
6902 in_system_header
= DECL_IN_SYSTEM_HEADER (typedecl
);
6904 TYPE_HAS_USER_CONSTRUCTOR (type
) = TYPE_HAS_USER_CONSTRUCTOR (pattern
);
6905 TYPE_HAS_NEW_OPERATOR (type
) = TYPE_HAS_NEW_OPERATOR (pattern
);
6906 TYPE_HAS_ARRAY_NEW_OPERATOR (type
) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern
);
6907 TYPE_GETS_DELETE (type
) = TYPE_GETS_DELETE (pattern
);
6908 TYPE_HAS_ASSIGN_REF (type
) = TYPE_HAS_ASSIGN_REF (pattern
);
6909 TYPE_HAS_CONST_ASSIGN_REF (type
) = TYPE_HAS_CONST_ASSIGN_REF (pattern
);
6910 TYPE_HAS_INIT_REF (type
) = TYPE_HAS_INIT_REF (pattern
);
6911 TYPE_HAS_CONST_INIT_REF (type
) = TYPE_HAS_CONST_INIT_REF (pattern
);
6912 TYPE_HAS_DEFAULT_CONSTRUCTOR (type
) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern
);
6913 TYPE_HAS_CONVERSION (type
) = TYPE_HAS_CONVERSION (pattern
);
6914 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
6915 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
6916 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
6917 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
6918 if (ANON_AGGR_TYPE_P (pattern
))
6919 SET_ANON_AGGR_TYPE_P (type
);
6920 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
6922 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
6923 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
6926 pbinfo
= TYPE_BINFO (pattern
);
6928 /* We should never instantiate a nested class before its enclosing
6929 class; we need to look up the nested class by name before we can
6930 instantiate it, and that lookup should instantiate the enclosing
6932 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
6933 || COMPLETE_TYPE_P (TYPE_CONTEXT (type
))
6934 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type
)));
6936 base_list
= NULL_TREE
;
6937 if (BINFO_N_BASE_BINFOS (pbinfo
))
6940 tree context
= TYPE_CONTEXT (type
);
6944 /* We must enter the scope containing the type, as that is where
6945 the accessibility of types named in dependent bases are
6947 pushed_scope
= push_scope (context
? context
: global_namespace
);
6949 /* Substitute into each of the bases to determine the actual
6951 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
6954 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
6955 tree expanded_bases
= NULL_TREE
;
6958 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
6961 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
6962 args
, tf_error
, NULL_TREE
);
6963 if (expanded_bases
== error_mark_node
)
6966 len
= TREE_VEC_LENGTH (expanded_bases
);
6969 for (idx
= 0; idx
< len
; idx
++)
6972 /* Extract the already-expanded base class. */
6973 base
= TREE_VEC_ELT (expanded_bases
, idx
);
6975 /* Substitute to figure out the base class. */
6976 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
6979 if (base
== error_mark_node
)
6982 base_list
= tree_cons (access
, base
, base_list
);
6983 if (BINFO_VIRTUAL_P (pbase_binfo
))
6984 TREE_TYPE (base_list
) = integer_type_node
;
6988 /* The list is now in reverse order; correct that. */
6989 base_list
= nreverse (base_list
);
6992 pop_scope (pushed_scope
);
6994 /* Now call xref_basetypes to set up all the base-class
6996 xref_basetypes (type
, base_list
);
6998 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
6999 (int) ATTR_FLAG_TYPE_IN_PLACE
,
7000 args
, tf_error
, NULL_TREE
);
7002 /* Now that our base classes are set up, enter the scope of the
7003 class, so that name lookups into base classes, etc. will work
7004 correctly. This is precisely analogous to what we do in
7005 begin_class_definition when defining an ordinary non-template
7006 class, except we also need to push the enclosing classes. */
7007 push_nested_class (type
);
7009 /* Now members are processed in the order of declaration. */
7010 for (member
= CLASSTYPE_DECL_LIST (pattern
);
7011 member
; member
= TREE_CHAIN (member
))
7013 tree t
= TREE_VALUE (member
);
7015 if (TREE_PURPOSE (member
))
7019 /* Build new CLASSTYPE_NESTED_UTDS. */
7022 bool class_template_p
;
7024 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
7025 && TYPE_LANG_SPECIFIC (t
)
7026 && CLASSTYPE_IS_TEMPLATE (t
));
7027 /* If the member is a class template, then -- even after
7028 substitution -- there may be dependent types in the
7029 template argument list for the class. We increment
7030 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7031 that function will assume that no types are dependent
7032 when outside of a template. */
7033 if (class_template_p
)
7034 ++processing_template_decl
;
7035 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
7036 if (class_template_p
)
7037 --processing_template_decl
;
7038 if (newtag
== error_mark_node
)
7041 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
7043 tree name
= TYPE_IDENTIFIER (t
);
7045 if (class_template_p
)
7046 /* Unfortunately, lookup_template_class sets
7047 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7048 instantiation (i.e., for the type of a member
7049 template class nested within a template class.)
7050 This behavior is required for
7051 maybe_process_partial_specialization to work
7052 correctly, but is not accurate in this case;
7053 the TAG is not an instantiation of anything.
7054 (The corresponding TEMPLATE_DECL is an
7055 instantiation, but the TYPE is not.) */
7056 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
7058 /* Now, we call pushtag to put this NEWTAG into the scope of
7059 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7060 pushtag calling push_template_decl. We don't have to do
7061 this for enums because it will already have been done in
7064 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
7065 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
7068 else if (TREE_CODE (t
) == FUNCTION_DECL
7069 || DECL_FUNCTION_TEMPLATE_P (t
))
7071 /* Build new TYPE_METHODS. */
7074 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7075 ++processing_template_decl
;
7076 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
7077 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7078 --processing_template_decl
;
7079 set_current_access_from_decl (r
);
7080 finish_member_declaration (r
);
7084 /* Build new TYPE_FIELDS. */
7085 if (TREE_CODE (t
) == STATIC_ASSERT
)
7088 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
7089 tf_warning_or_error
, NULL_TREE
,
7090 /*integral_constant_expression_p=*/true);
7091 finish_static_assert (condition
,
7092 STATIC_ASSERT_MESSAGE (t
),
7093 STATIC_ASSERT_SOURCE_LOCATION (t
),
7096 else if (TREE_CODE (t
) != CONST_DECL
)
7100 /* The the file and line for this declaration, to
7101 assist in error message reporting. Since we
7102 called push_tinst_level above, we don't need to
7104 input_location
= DECL_SOURCE_LOCATION (t
);
7106 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7107 ++processing_template_decl
;
7108 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
7109 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7110 --processing_template_decl
;
7111 if (TREE_CODE (r
) == VAR_DECL
)
7115 [t]he initialization (and any associated
7116 side-effects) of a static data member does
7117 not occur unless the static data member is
7118 itself used in a way that requires the
7119 definition of the static data member to
7122 Therefore, we do not substitute into the
7123 initialized for the static data member here. */
7124 finish_static_data_member_decl
7127 /*init_const_expr_p=*/false,
7128 /*asmspec_tree=*/NULL_TREE
,
7130 if (DECL_INITIALIZED_IN_CLASS_P (r
))
7131 check_static_variable_definition (r
, TREE_TYPE (r
));
7133 else if (TREE_CODE (r
) == FIELD_DECL
)
7135 /* Determine whether R has a valid type and can be
7136 completed later. If R is invalid, then it is
7137 replaced by error_mark_node so that it will not be
7138 added to TYPE_FIELDS. */
7139 tree rtype
= TREE_TYPE (r
);
7140 if (can_complete_type_without_circularity (rtype
))
7141 complete_type (rtype
);
7143 if (!COMPLETE_TYPE_P (rtype
))
7145 cxx_incomplete_type_error (r
, rtype
);
7146 r
= error_mark_node
;
7150 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7151 such a thing will already have been added to the field
7152 list by tsubst_enum in finish_member_declaration in the
7153 CLASSTYPE_NESTED_UTDS case above. */
7154 if (!(TREE_CODE (r
) == TYPE_DECL
7155 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
7156 && DECL_ARTIFICIAL (r
)))
7158 set_current_access_from_decl (r
);
7159 finish_member_declaration (r
);
7166 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
))
7168 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7170 tree friend_type
= t
;
7171 bool adjust_processing_template_decl
= false;
7173 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
7175 /* template <class T> friend class C; */
7176 friend_type
= tsubst_friend_class (friend_type
, args
);
7177 adjust_processing_template_decl
= true;
7179 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
7181 /* template <class T> friend class C::D; */
7182 friend_type
= tsubst (friend_type
, args
,
7183 tf_warning_or_error
, NULL_TREE
);
7184 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
7185 friend_type
= TREE_TYPE (friend_type
);
7186 adjust_processing_template_decl
= true;
7188 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
)
7190 /* This could be either
7194 when dependent_type_p is false or
7196 template <class U> friend class T::C;
7199 friend_type
= tsubst (friend_type
, args
,
7200 tf_warning_or_error
, NULL_TREE
);
7201 /* Bump processing_template_decl for correct
7202 dependent_type_p calculation. */
7203 ++processing_template_decl
;
7204 if (dependent_type_p (friend_type
))
7205 adjust_processing_template_decl
= true;
7206 --processing_template_decl
;
7208 else if (!CLASSTYPE_USE_TEMPLATE (friend_type
)
7209 && hidden_name_p (TYPE_NAME (friend_type
)))
7213 where C hasn't been declared yet. Let's lookup name
7214 from namespace scope directly, bypassing any name that
7215 come from dependent base class. */
7216 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
7218 /* The call to xref_tag_from_type does injection for friend
7220 push_nested_namespace (ns
);
7222 xref_tag_from_type (friend_type
, NULL_TREE
,
7223 /*tag_scope=*/ts_current
);
7224 pop_nested_namespace (ns
);
7226 else if (uses_template_parms (friend_type
))
7227 /* friend class C<T>; */
7228 friend_type
= tsubst (friend_type
, args
,
7229 tf_warning_or_error
, NULL_TREE
);
7234 where C is already declared or
7236 friend class C<int>;
7238 We don't have to do anything in these cases. */
7240 if (adjust_processing_template_decl
)
7241 /* Trick make_friend_class into realizing that the friend
7242 we're adding is a template, not an ordinary class. It's
7243 important that we use make_friend_class since it will
7244 perform some error-checking and output cross-reference
7246 ++processing_template_decl
;
7248 if (friend_type
!= error_mark_node
)
7249 make_friend_class (type
, friend_type
, /*complain=*/false);
7251 if (adjust_processing_template_decl
)
7252 --processing_template_decl
;
7256 /* Build new DECL_FRIENDLIST. */
7259 /* The the file and line for this declaration, to
7260 assist in error message reporting. Since we
7261 called push_tinst_level above, we don't need to
7263 input_location
= DECL_SOURCE_LOCATION (t
);
7265 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7267 ++processing_template_decl
;
7268 push_deferring_access_checks (dk_no_check
);
7271 r
= tsubst_friend_function (t
, args
);
7272 add_friend (type
, r
, /*complain=*/false);
7273 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7275 pop_deferring_access_checks ();
7276 --processing_template_decl
;
7282 /* Set the file and line number information to whatever is given for
7283 the class itself. This puts error messages involving generated
7284 implicit functions at a predictable point, and the same point
7285 that would be used for non-template classes. */
7286 input_location
= DECL_SOURCE_LOCATION (typedecl
);
7288 unreverse_member_declarations (type
);
7289 finish_struct_1 (type
);
7290 TYPE_BEING_DEFINED (type
) = 0;
7292 /* Now that the class is complete, instantiate default arguments for
7293 any member functions. We don't do this earlier because the
7294 default arguments may reference members of the class. */
7295 if (!PRIMARY_TEMPLATE_P (template))
7296 for (t
= TYPE_METHODS (type
); t
; t
= TREE_CHAIN (t
))
7297 if (TREE_CODE (t
) == FUNCTION_DECL
7298 /* Implicitly generated member functions will not have template
7299 information; they are not instantiations, but instead are
7300 created "fresh" for each instantiation. */
7301 && DECL_TEMPLATE_INFO (t
))
7302 tsubst_default_arguments (t
);
7304 pop_nested_class ();
7305 pop_from_top_level ();
7306 pop_deferring_access_checks ();
7309 /* The vtable for a template class can be emitted in any translation
7310 unit in which the class is instantiated. When there is no key
7311 method, however, finish_struct_1 will already have added TYPE to
7312 the keyed_classes list. */
7313 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
7314 keyed_classes
= tree_cons (NULL_TREE
, type
, keyed_classes
);
7320 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
7326 else if (TYPE_P (t
))
7327 r
= tsubst (t
, args
, complain
, in_decl
);
7330 r
= tsubst_expr (t
, args
, complain
, in_decl
,
7331 /*integral_constant_expression_p=*/true);
7332 r
= fold_non_dependent_expr (r
);
7337 /* Substitute ARGS into T, which is an pack expansion
7338 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7339 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7340 (if only a partial substitution could be performed) or
7341 ERROR_MARK_NODE if there was an error. */
7343 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
7347 tree pack
, packs
= NULL_TREE
, unsubstituted_packs
= NULL_TREE
;
7348 tree first_arg_pack
; int i
, len
= -1;
7352 gcc_assert (PACK_EXPANSION_P (t
));
7353 pattern
= PACK_EXPANSION_PATTERN (t
);
7355 /* Determine the argument packs that will instantiate the parameter
7356 packs used in the expansion expression. While we're at it,
7357 compute the number of arguments to be expanded and make sure it
7359 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
7360 pack
= TREE_CHAIN (pack
))
7362 tree parm_pack
= TREE_VALUE (pack
);
7363 tree arg_pack
= NULL_TREE
;
7364 tree orig_arg
= NULL_TREE
;
7366 if (TREE_CODE (parm_pack
) == PARM_DECL
)
7367 arg_pack
= retrieve_local_specialization (parm_pack
);
7370 int level
, idx
, levels
;
7371 template_parm_level_and_index (parm_pack
, &level
, &idx
);
7373 levels
= TMPL_ARGS_DEPTH (args
);
7374 if (level
<= levels
)
7375 arg_pack
= TMPL_ARG (args
, level
, idx
);
7378 orig_arg
= arg_pack
;
7379 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
7380 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
7382 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
7383 /* This can only happen if we forget to expand an argument
7384 pack somewhere else. Just return an error, silently. */
7386 result
= make_tree_vec (1);
7387 TREE_VEC_ELT (result
, 0) = error_mark_node
;
7392 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
)) == 1
7393 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack
), 0)))
7395 tree expansion
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack
), 0);
7396 tree pattern
= PACK_EXPANSION_PATTERN (expansion
);
7397 if ((TYPE_P (pattern
) && same_type_p (pattern
, parm_pack
))
7398 || (!TYPE_P (pattern
) && cp_tree_equal (parm_pack
, pattern
)))
7399 /* The argument pack that the parameter maps to is just an
7400 expansion of the parameter itself, such as one would
7401 find in the implicit typedef of a class inside the
7402 class itself. Consider this parameter "unsubstituted",
7403 so that we will maintain the outer pack expansion. */
7404 arg_pack
= NULL_TREE
;
7410 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
7412 /* It's all-or-nothing with incomplete argument packs. */
7413 if (incomplete
&& !ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
7414 return error_mark_node
;
7416 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
7422 first_arg_pack
= arg_pack
;
7424 else if (len
!= my_len
)
7426 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
7427 error ("mismatched argument pack lengths while expanding "
7431 error ("mismatched argument pack lengths while expanding "
7434 return error_mark_node
;
7437 /* Keep track of the parameter packs and their corresponding
7439 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
7440 TREE_TYPE (packs
) = orig_arg
;
7443 /* We can't substitute for this parameter pack. */
7444 unsubstituted_packs
= tree_cons (TREE_PURPOSE (pack
),
7446 unsubstituted_packs
);
7449 /* We cannot expand this expansion expression, because we don't have
7450 all of the argument packs we need. Substitute into the pattern
7451 and return a PACK_EXPANSION_*. The caller will need to deal with
7453 if (unsubstituted_packs
)
7454 return make_pack_expansion (tsubst (pattern
, args
, complain
,
7457 /* We could not find any argument packs that work. */
7459 return error_mark_node
;
7461 /* For each argument in each argument pack, substitute into the
7463 result
= make_tree_vec (len
+ incomplete
);
7464 for (i
= 0; i
< len
+ incomplete
; ++i
)
7466 /* For parameter pack, change the substitution of the parameter
7467 pack to the ith argument in its argument pack, then expand
7469 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
7471 tree parm
= TREE_PURPOSE (pack
);
7473 if (TREE_CODE (parm
) == PARM_DECL
)
7475 /* Select the Ith argument from the pack. */
7476 tree arg
= make_node (ARGUMENT_PACK_SELECT
);
7477 ARGUMENT_PACK_SELECT_FROM_PACK (arg
) = TREE_VALUE (pack
);
7478 ARGUMENT_PACK_SELECT_INDEX (arg
) = i
;
7480 register_local_specialization (arg
, parm
);
7486 template_parm_level_and_index (parm
, &level
, &idx
);
7490 /* Select the Ith argument from the pack. */
7491 value
= make_node (ARGUMENT_PACK_SELECT
);
7492 ARGUMENT_PACK_SELECT_FROM_PACK (value
) = TREE_VALUE (pack
);
7493 ARGUMENT_PACK_SELECT_INDEX (value
) = i
;
7496 /* Update the corresponding argument. */
7497 TMPL_ARG (args
, level
, idx
) = value
;
7501 /* Substitute into the PATTERN with the altered arguments. */
7502 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
7503 TREE_VEC_ELT (result
, i
) =
7504 tsubst_expr (pattern
, args
, complain
, in_decl
,
7505 /*integral_constant_expression_p=*/false);
7507 TREE_VEC_ELT (result
, i
) = tsubst (pattern
, args
, complain
, in_decl
);
7510 /* When we have incomplete argument packs, the last "expanded"
7511 result is itself a pack expansion, which allows us
7512 to deduce more arguments. */
7513 TREE_VEC_ELT (result
, i
) =
7514 make_pack_expansion (TREE_VEC_ELT (result
, i
));
7516 if (TREE_VEC_ELT (result
, i
) == error_mark_node
)
7518 result
= error_mark_node
;
7523 /* Update ARGS to restore the substitution from parameter packs to
7524 their argument packs. */
7525 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
7527 tree parm
= TREE_PURPOSE (pack
);
7529 if (TREE_CODE (parm
) == PARM_DECL
)
7530 register_local_specialization (TREE_TYPE (pack
), parm
);
7534 template_parm_level_and_index (parm
, &level
, &idx
);
7536 /* Update the corresponding argument. */
7537 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
7538 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
7541 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
7548 /* Substitute ARGS into the vector or list of template arguments T. */
7551 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
7554 int len
= TREE_VEC_LENGTH (t
);
7555 int need_new
= 0, i
, expanded_len_adjust
= 0, out
;
7556 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
7558 for (i
= 0; i
< len
; i
++)
7560 tree orig_arg
= TREE_VEC_ELT (t
, i
);
7563 if (TREE_CODE (orig_arg
) == TREE_VEC
)
7564 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
7565 else if (PACK_EXPANSION_P (orig_arg
))
7567 /* Substitute into an expansion expression. */
7568 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
7570 if (TREE_CODE (new_arg
) == TREE_VEC
)
7571 /* Add to the expanded length adjustment the number of
7572 expanded arguments. We subtract one from this
7573 measurement, because the argument pack expression
7574 itself is already counted as 1 in
7575 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7576 the argument pack is empty. */
7577 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
7579 else if (ARGUMENT_PACK_P (orig_arg
))
7581 /* Substitute into each of the arguments. */
7582 new_arg
= make_node (TREE_CODE (orig_arg
));
7584 SET_ARGUMENT_PACK_ARGS (
7586 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
7587 args
, complain
, in_decl
));
7589 if (ARGUMENT_PACK_ARGS (new_arg
) == error_mark_node
)
7590 new_arg
= error_mark_node
;
7592 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
) {
7593 TREE_TYPE (new_arg
) = tsubst (TREE_TYPE (orig_arg
), args
,
7595 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
7597 if (TREE_TYPE (new_arg
) == error_mark_node
)
7598 new_arg
= error_mark_node
;
7602 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
7604 if (new_arg
== error_mark_node
)
7605 return error_mark_node
;
7608 if (new_arg
!= orig_arg
)
7615 /* Make space for the expanded arguments coming from template
7617 t
= make_tree_vec (len
+ expanded_len_adjust
);
7618 for (i
= 0, out
= 0; i
< len
; i
++)
7620 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
7621 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
7622 && TREE_CODE (elts
[i
]) == TREE_VEC
)
7626 /* Now expand the template argument pack "in place". */
7627 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
7628 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
7632 TREE_VEC_ELT (t
, out
) = elts
[i
];
7640 /* Return the result of substituting ARGS into the template parameters
7641 given by PARMS. If there are m levels of ARGS and m + n levels of
7642 PARMS, then the result will contain n levels of PARMS. For
7643 example, if PARMS is `template <class T> template <class U>
7644 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7645 result will be `template <int*, double, class V>'. */
7648 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
7653 /* When substituting into a template, we must set
7654 PROCESSING_TEMPLATE_DECL as the template parameters may be
7655 dependent if they are based on one-another, and the dependency
7656 predicates are short-circuit outside of templates. */
7657 ++processing_template_decl
;
7659 for (new_parms
= &r
;
7660 TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
7661 new_parms
= &(TREE_CHAIN (*new_parms
)),
7662 parms
= TREE_CHAIN (parms
))
7665 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
7668 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
7674 if (parms
== error_mark_node
)
7677 tuple
= TREE_VEC_ELT (TREE_VALUE (parms
), i
);
7679 if (tuple
== error_mark_node
)
7682 default_value
= TREE_PURPOSE (tuple
);
7683 parm_decl
= TREE_VALUE (tuple
);
7685 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
7686 if (TREE_CODE (parm_decl
) == PARM_DECL
7687 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
7688 parm_decl
= error_mark_node
;
7689 default_value
= tsubst_template_arg (default_value
, args
,
7690 complain
, NULL_TREE
);
7692 tuple
= build_tree_list (default_value
, parm_decl
);
7693 TREE_VEC_ELT (new_vec
, i
) = tuple
;
7697 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
7698 - TMPL_ARGS_DEPTH (args
)),
7699 new_vec
, NULL_TREE
);
7702 --processing_template_decl
;
7707 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7708 type T. If T is not an aggregate or enumeration type, it is
7709 handled as if by tsubst. IN_DECL is as for tsubst. If
7710 ENTERING_SCOPE is nonzero, T is the context for a template which
7711 we are presently tsubst'ing. Return the substituted value. */
7714 tsubst_aggr_type (tree t
,
7716 tsubst_flags_t complain
,
7723 switch (TREE_CODE (t
))
7726 if (TYPE_PTRMEMFUNC_P (t
))
7727 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
7729 /* Else fall through. */
7732 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
7737 bool saved_skip_evaluation
;
7739 /* In "sizeof(X<I>)" we need to evaluate "I". */
7740 saved_skip_evaluation
= skip_evaluation
;
7741 skip_evaluation
= false;
7743 /* First, determine the context for the type we are looking
7745 context
= TYPE_CONTEXT (t
);
7748 context
= tsubst_aggr_type (context
, args
, complain
,
7749 in_decl
, /*entering_scope=*/1);
7750 /* If context is a nested class inside a class template,
7751 it may still need to be instantiated (c++/33959). */
7752 if (TYPE_P (context
))
7753 context
= complete_type (context
);
7756 /* Then, figure out what arguments are appropriate for the
7757 type we are trying to find. For example, given:
7759 template <class T> struct S;
7760 template <class T, class U> void f(T, U) { S<U> su; }
7762 and supposing that we are instantiating f<int, double>,
7763 then our ARGS will be {int, double}, but, when looking up
7764 S we only want {double}. */
7765 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
7767 if (argvec
== error_mark_node
)
7768 r
= error_mark_node
;
7771 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
7772 entering_scope
, complain
);
7773 r
= cp_build_qualified_type_real (r
, TYPE_QUALS (t
), complain
);
7776 skip_evaluation
= saved_skip_evaluation
;
7781 /* This is not a template type, so there's nothing to do. */
7785 return tsubst (t
, args
, complain
, in_decl
);
7789 /* Substitute into the default argument ARG (a default argument for
7790 FN), which has the indicated TYPE. */
7793 tsubst_default_argument (tree fn
, tree type
, tree arg
)
7795 tree saved_class_ptr
= NULL_TREE
;
7796 tree saved_class_ref
= NULL_TREE
;
7798 /* This default argument came from a template. Instantiate the
7799 default argument here, not in tsubst. In the case of
7808 we must be careful to do name lookup in the scope of S<T>,
7809 rather than in the current class. */
7810 push_access_scope (fn
);
7811 /* The "this" pointer is not valid in a default argument. */
7814 saved_class_ptr
= current_class_ptr
;
7815 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
7816 saved_class_ref
= current_class_ref
;
7817 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
7820 push_deferring_access_checks(dk_no_deferred
);
7821 /* The default argument expression may cause implicitly defined
7822 member functions to be synthesized, which will result in garbage
7823 collection. We must treat this situation as if we were within
7824 the body of function so as to avoid collecting live data on the
7827 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
7828 tf_warning_or_error
, NULL_TREE
,
7829 /*integral_constant_expression_p=*/false);
7831 pop_deferring_access_checks();
7833 /* Restore the "this" pointer. */
7836 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
7837 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
7840 pop_access_scope (fn
);
7842 /* Make sure the default argument is reasonable. */
7843 arg
= check_default_argument (type
, arg
);
7848 /* Substitute into all the default arguments for FN. */
7851 tsubst_default_arguments (tree fn
)
7856 tmpl_args
= DECL_TI_ARGS (fn
);
7858 /* If this function is not yet instantiated, we certainly don't need
7859 its default arguments. */
7860 if (uses_template_parms (tmpl_args
))
7863 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
7865 arg
= TREE_CHAIN (arg
))
7866 if (TREE_PURPOSE (arg
))
7867 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
7869 TREE_PURPOSE (arg
));
7872 /* Substitute the ARGS into the T, which is a _DECL. Return the
7873 result of the substitution. Issue error and warning messages under
7874 control of COMPLAIN. */
7877 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
7879 location_t saved_loc
;
7883 /* Set the filename and linenumber to improve error-reporting. */
7884 saved_loc
= input_location
;
7885 input_location
= DECL_SOURCE_LOCATION (t
);
7887 switch (TREE_CODE (t
))
7891 /* We can get here when processing a member function template,
7892 member class template, and template template parameter of
7893 a template class. */
7894 tree decl
= DECL_TEMPLATE_RESULT (t
);
7899 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
7901 /* Template template parameter is treated here. */
7902 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7903 if (new_type
== error_mark_node
)
7904 return error_mark_node
;
7907 TREE_CHAIN (r
) = NULL_TREE
;
7908 TREE_TYPE (r
) = new_type
;
7909 DECL_TEMPLATE_RESULT (r
)
7910 = build_decl (TYPE_DECL
, DECL_NAME (decl
), new_type
);
7911 DECL_TEMPLATE_PARMS (r
)
7912 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
7914 TYPE_NAME (new_type
) = r
;
7918 /* We might already have an instance of this template.
7919 The ARGS are for the surrounding class type, so the
7920 full args contain the tsubst'd args for the context,
7921 plus the innermost args from the template decl. */
7922 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
7923 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
7924 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
7925 /* Because this is a template, the arguments will still be
7926 dependent, even after substitution. If
7927 PROCESSING_TEMPLATE_DECL is not set, the dependency
7928 predicates will short-circuit. */
7929 ++processing_template_decl
;
7930 full_args
= tsubst_template_args (tmpl_args
, args
,
7932 --processing_template_decl
;
7933 if (full_args
== error_mark_node
)
7934 return error_mark_node
;
7936 /* tsubst_template_args doesn't copy the vector if
7937 nothing changed. But, *something* should have
7939 gcc_assert (full_args
!= tmpl_args
);
7941 spec
= retrieve_specialization (t
, full_args
,
7942 /*class_specializations_p=*/true);
7943 if (spec
!= NULL_TREE
)
7949 /* Make a new template decl. It will be similar to the
7950 original, but will record the current template arguments.
7951 We also create a new function declaration, which is just
7952 like the old one, but points to this new template, rather
7953 than the old one. */
7955 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
7956 TREE_CHAIN (r
) = NULL_TREE
;
7958 DECL_TEMPLATE_INFO (r
) = build_tree_list (t
, args
);
7960 if (TREE_CODE (decl
) == TYPE_DECL
)
7963 ++processing_template_decl
;
7964 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
7965 --processing_template_decl
;
7966 if (new_type
== error_mark_node
)
7967 return error_mark_node
;
7969 TREE_TYPE (r
) = new_type
;
7970 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
7971 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
7972 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
7973 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
7978 ++processing_template_decl
;
7979 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
7980 --processing_template_decl
;
7981 if (new_decl
== error_mark_node
)
7982 return error_mark_node
;
7984 DECL_TEMPLATE_RESULT (r
) = new_decl
;
7985 DECL_TI_TEMPLATE (new_decl
) = r
;
7986 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
7987 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
7988 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
7991 SET_DECL_IMPLICIT_INSTANTIATION (r
);
7992 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
7993 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
7995 /* The template parameters for this new template are all the
7996 template parameters for the old template, except the
7997 outermost level of parameters. */
7998 DECL_TEMPLATE_PARMS (r
)
7999 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
8002 if (PRIMARY_TEMPLATE_P (t
))
8003 DECL_PRIMARY_TEMPLATE (r
) = r
;
8005 if (TREE_CODE (decl
) != TYPE_DECL
)
8006 /* Record this non-type partial instantiation. */
8007 register_specialization (r
, t
,
8008 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
8016 tree argvec
= NULL_TREE
;
8024 /* Nobody should be tsubst'ing into non-template functions. */
8025 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
8027 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
8032 /* If T is not dependent, just return it. We have to
8033 increment PROCESSING_TEMPLATE_DECL because
8034 value_dependent_expression_p assumes that nothing is
8035 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8036 ++processing_template_decl
;
8037 dependent_p
= value_dependent_expression_p (t
);
8038 --processing_template_decl
;
8042 /* Calculate the most general template of which R is a
8043 specialization, and the complete set of arguments used to
8045 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
8046 argvec
= tsubst_template_args (DECL_TI_ARGS
8047 (DECL_TEMPLATE_RESULT (gen_tmpl
)),
8048 args
, complain
, in_decl
);
8050 /* Check to see if we already have this specialization. */
8051 spec
= retrieve_specialization (gen_tmpl
, argvec
,
8052 /*class_specializations_p=*/false);
8060 /* We can see more levels of arguments than parameters if
8061 there was a specialization of a member template, like
8064 template <class T> struct S { template <class U> void f(); }
8065 template <> template <class U> void S<int>::f(U);
8067 Here, we'll be substituting into the specialization,
8068 because that's where we can find the code we actually
8069 want to generate, but we'll have enough arguments for
8070 the most general template.
8072 We also deal with the peculiar case:
8074 template <class T> struct S {
8075 template <class U> friend void f();
8077 template <class U> void f() {}
8079 template void f<double>();
8081 Here, the ARGS for the instantiation of will be {int,
8082 double}. But, we only need as many ARGS as there are
8083 levels of template parameters in CODE_PATTERN. We are
8084 careful not to get fooled into reducing the ARGS in
8087 template <class T> struct S { template <class U> void f(U); }
8088 template <class T> template <> void S<T>::f(int) {}
8090 which we can spot because the pattern will be a
8091 specialization in this case. */
8092 args_depth
= TMPL_ARGS_DEPTH (args
);
8094 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
8095 if (args_depth
> parms_depth
8096 && !DECL_TEMPLATE_SPECIALIZATION (t
))
8097 args
= get_innermost_template_args (args
, parms_depth
);
8101 /* This special case arises when we have something like this:
8103 template <class T> struct S {
8104 friend void f<int>(int, double);
8107 Here, the DECL_TI_TEMPLATE for the friend declaration
8108 will be an IDENTIFIER_NODE. We are being called from
8109 tsubst_friend_function, and we want only to create a
8110 new decl (R) with appropriate types so that we can call
8111 determine_specialization. */
8112 gen_tmpl
= NULL_TREE
;
8115 if (DECL_CLASS_SCOPE_P (t
))
8117 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
8121 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
8122 complain
, t
, /*entering_scope=*/1);
8127 ctx
= DECL_CONTEXT (t
);
8129 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8130 if (type
== error_mark_node
)
8131 return error_mark_node
;
8133 /* We do NOT check for matching decls pushed separately at this
8134 point, as they may not represent instantiations of this
8135 template, and in any case are considered separate under the
8138 DECL_USE_TEMPLATE (r
) = 0;
8139 TREE_TYPE (r
) = type
;
8140 /* Clear out the mangled name and RTL for the instantiation. */
8141 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
8142 SET_DECL_RTL (r
, NULL_RTX
);
8143 DECL_INITIAL (r
) = NULL_TREE
;
8144 DECL_CONTEXT (r
) = ctx
;
8146 if (member
&& DECL_CONV_FN_P (r
))
8147 /* Type-conversion operator. Reconstruct the name, in
8148 case it's the name of one of the template's parameters. */
8149 DECL_NAME (r
) = mangle_conv_op_name_for_type (TREE_TYPE (type
));
8151 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
8153 DECL_RESULT (r
) = NULL_TREE
;
8155 TREE_STATIC (r
) = 0;
8156 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
8157 DECL_EXTERNAL (r
) = 1;
8158 /* If this is an instantiation of a function with internal
8159 linkage, we already know what object file linkage will be
8160 assigned to the instantiation. */
8161 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
8162 DECL_DEFER_OUTPUT (r
) = 0;
8163 TREE_CHAIN (r
) = NULL_TREE
;
8164 DECL_PENDING_INLINE_INFO (r
) = 0;
8165 DECL_PENDING_INLINE_P (r
) = 0;
8166 DECL_SAVED_TREE (r
) = NULL_TREE
;
8168 if (DECL_CLONED_FUNCTION (r
))
8170 DECL_CLONED_FUNCTION (r
) = tsubst (DECL_CLONED_FUNCTION (t
),
8172 TREE_CHAIN (r
) = TREE_CHAIN (DECL_CLONED_FUNCTION (r
));
8173 TREE_CHAIN (DECL_CLONED_FUNCTION (r
)) = r
;
8176 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8177 this in the special friend case mentioned above where
8178 GEN_TMPL is NULL. */
8181 DECL_TEMPLATE_INFO (r
)
8182 = tree_cons (gen_tmpl
, argvec
, NULL_TREE
);
8183 SET_DECL_IMPLICIT_INSTANTIATION (r
);
8184 register_specialization (r
, gen_tmpl
, argvec
, false);
8186 /* We're not supposed to instantiate default arguments
8187 until they are called, for a template. But, for a
8190 template <class T> void f ()
8191 { extern void g(int i = T()); }
8193 we should do the substitution when the template is
8194 instantiated. We handle the member function case in
8195 instantiate_class_template since the default arguments
8196 might refer to other members of the class. */
8198 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
8199 && !uses_template_parms (argvec
))
8200 tsubst_default_arguments (r
);
8203 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
8205 /* Copy the list of befriending classes. */
8206 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
8208 friends
= &TREE_CHAIN (*friends
))
8210 *friends
= copy_node (*friends
);
8211 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
8216 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
8218 maybe_retrofit_in_chrg (r
);
8219 if (DECL_CONSTRUCTOR_P (r
))
8220 grok_ctor_properties (ctx
, r
);
8221 /* If this is an instantiation of a member template, clone it.
8222 If it isn't, that'll be handled by
8223 clone_constructors_and_destructors. */
8224 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
8225 clone_function_decl (r
, /*update_method_vec_p=*/0);
8227 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r
))
8228 && !grok_op_properties (r
, (complain
& tf_error
) != 0))
8229 return error_mark_node
;
8231 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
8232 SET_DECL_FRIEND_CONTEXT (r
,
8233 tsubst (DECL_FRIEND_CONTEXT (t
),
8234 args
, complain
, in_decl
));
8236 /* Possibly limit visibility based on template args. */
8237 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
8238 if (DECL_VISIBILITY_SPECIFIED (t
))
8240 DECL_VISIBILITY_SPECIFIED (r
) = 0;
8242 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
8244 determine_visibility (r
);
8246 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
8247 args
, complain
, in_decl
);
8253 tree type
= NULL_TREE
;
8255 tree expanded_types
= NULL_TREE
;
8256 tree prev_r
= NULL_TREE
;
8257 tree first_r
= NULL_TREE
;
8259 if (FUNCTION_PARAMETER_PACK_P (t
))
8261 /* If there is a local specialization that isn't a
8262 parameter pack, it means that we're doing a "simple"
8263 substitution from inside tsubst_pack_expansion. Just
8264 return the local specialization (which will be a single
8266 tree spec
= retrieve_local_specialization (t
);
8268 && TREE_CODE (spec
) == PARM_DECL
8269 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
8272 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8273 the parameters in this function parameter pack. */
8274 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
8276 if (TREE_CODE (expanded_types
) == TREE_VEC
)
8278 len
= TREE_VEC_LENGTH (expanded_types
);
8280 /* Zero-length parameter packs are boring. Just substitute
8283 return tsubst (TREE_CHAIN (t
), args
, complain
,
8288 /* All we did was update the type. Make a note of that. */
8289 type
= expanded_types
;
8290 expanded_types
= NULL_TREE
;
8294 /* Loop through all of the parameter's we'll build. When T is
8295 a function parameter pack, LEN is the number of expanded
8296 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8298 for (i
= 0; i
< len
; ++i
)
8302 if (DECL_TEMPLATE_PARM_P (t
))
8303 SET_DECL_TEMPLATE_PARM_P (r
);
8306 /* We're on the Ith parameter of the function parameter
8309 /* Get the Ith type. */
8310 type
= TREE_VEC_ELT (expanded_types
, i
);
8313 /* Rename the parameter to include the index. */
8315 make_ith_pack_parameter_name (DECL_NAME (r
), i
);
8318 /* We're dealing with a normal parameter. */
8319 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8321 type
= type_decays_to (type
);
8322 TREE_TYPE (r
) = type
;
8323 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
8325 if (DECL_INITIAL (r
))
8327 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
8328 DECL_INITIAL (r
) = TREE_TYPE (r
);
8330 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
8334 DECL_CONTEXT (r
) = NULL_TREE
;
8336 if (!DECL_TEMPLATE_PARM_P (r
))
8337 DECL_ARG_TYPE (r
) = type_passed_as (type
);
8339 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
8340 args
, complain
, in_decl
);
8342 /* Keep track of the first new parameter we
8343 generate. That's what will be returned to the
8348 /* Build a proper chain of parameters when substituting
8349 into a function parameter pack. */
8351 TREE_CHAIN (prev_r
) = r
;
8355 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
,
8356 complain
, TREE_CHAIN (t
));
8358 /* FIRST_R contains the start of the chain we've built. */
8368 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8369 if (type
== error_mark_node
)
8370 return error_mark_node
;
8371 TREE_TYPE (r
) = type
;
8372 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
8374 /* DECL_INITIAL gives the number of bits in a bit-field. */
8376 = tsubst_expr (DECL_INITIAL (t
), args
,
8378 /*integral_constant_expression_p=*/true);
8379 /* We don't have to set DECL_CONTEXT here; it is set by
8380 finish_member_declaration. */
8381 TREE_CHAIN (r
) = NULL_TREE
;
8382 if (VOID_TYPE_P (type
))
8383 error ("instantiation of %q+D as type %qT", r
, type
);
8385 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
8386 args
, complain
, in_decl
);
8391 /* We reach here only for member using decls. */
8392 if (DECL_DEPENDENT_P (t
))
8394 r
= do_class_using_decl
8395 (tsubst_copy (USING_DECL_SCOPE (t
), args
, complain
, in_decl
),
8396 tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
));
8398 r
= error_mark_node
;
8403 TREE_CHAIN (r
) = NULL_TREE
;
8410 tree argvec
= NULL_TREE
;
8411 tree gen_tmpl
= NULL_TREE
;
8413 tree tmpl
= NULL_TREE
;
8415 tree type
= NULL_TREE
;
8418 if (TREE_CODE (t
) == TYPE_DECL
8419 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
8421 /* If this is the canonical decl, we don't have to
8422 mess with instantiations, and often we can't (for
8423 typename, template type parms and such). Note that
8424 TYPE_NAME is not correct for the above test if
8425 we've copied the type for a typedef. */
8426 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8427 if (type
== error_mark_node
)
8428 return error_mark_node
;
8429 r
= TYPE_NAME (type
);
8433 /* Check to see if we already have the specialization we
8436 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
8438 /* T is a static data member or namespace-scope entity.
8439 We have to substitute into namespace-scope variables
8440 (even though such entities are never templates) because
8443 template <class T> void f() { extern T t; }
8445 where the entity referenced is not known until
8446 instantiation time. */
8448 ctx
= DECL_CONTEXT (t
);
8449 if (DECL_CLASS_SCOPE_P (t
))
8451 ctx
= tsubst_aggr_type (ctx
, args
,
8453 in_decl
, /*entering_scope=*/1);
8454 /* If CTX is unchanged, then T is in fact the
8455 specialization we want. That situation occurs when
8456 referencing a static data member within in its own
8457 class. We can use pointer equality, rather than
8458 same_type_p, because DECL_CONTEXT is always
8460 if (ctx
== DECL_CONTEXT (t
))
8466 tmpl
= DECL_TI_TEMPLATE (t
);
8467 gen_tmpl
= most_general_template (tmpl
);
8468 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
8469 spec
= (retrieve_specialization
8471 /*class_specializations_p=*/false));
8476 /* A local variable. */
8478 /* Subsequent calls to pushdecl will fill this in. */
8480 spec
= retrieve_local_specialization (t
);
8482 /* If we already have the specialization we need, there is
8483 nothing more to do. */
8490 /* Create a new node for the specialization we need. */
8492 if (type
== NULL_TREE
)
8493 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8494 if (TREE_CODE (r
) == VAR_DECL
)
8496 /* Even if the original location is out of scope, the
8497 newly substituted one is not. */
8498 DECL_DEAD_FOR_LOCAL (r
) = 0;
8499 DECL_INITIALIZED_P (r
) = 0;
8500 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
8501 if (type
== error_mark_node
)
8502 return error_mark_node
;
8503 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8505 /* It may seem that this case cannot occur, since:
8510 declares a function, not a variable. However:
8513 template <typename T> void g() { T t; }
8514 template void g<f>();
8516 is an attempt to declare a variable with function
8518 error ("variable %qD has function type",
8519 /* R is not yet sufficiently initialized, so we
8520 just use its name. */
8522 return error_mark_node
;
8524 type
= complete_type (type
);
8525 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
8526 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t
);
8527 type
= check_var_type (DECL_NAME (r
), type
);
8529 if (DECL_HAS_VALUE_EXPR_P (t
))
8531 tree ve
= DECL_VALUE_EXPR (t
);
8532 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
8533 /*constant_expression_p=*/false);
8534 SET_DECL_VALUE_EXPR (r
, ve
);
8537 else if (DECL_SELF_REFERENCE_P (t
))
8538 SET_DECL_SELF_REFERENCE_P (r
);
8539 TREE_TYPE (r
) = type
;
8540 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
8541 DECL_CONTEXT (r
) = ctx
;
8542 /* Clear out the mangled name and RTL for the instantiation. */
8543 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
8544 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
8545 SET_DECL_RTL (r
, NULL_RTX
);
8546 /* The initializer must not be expanded until it is required;
8548 DECL_INITIAL (r
) = NULL_TREE
;
8549 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
8550 SET_DECL_RTL (r
, NULL_RTX
);
8551 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
8552 if (TREE_CODE (r
) == VAR_DECL
)
8554 /* Possibly limit visibility based on template args. */
8555 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
8556 if (DECL_VISIBILITY_SPECIFIED (t
))
8558 DECL_VISIBILITY_SPECIFIED (r
) = 0;
8560 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
8562 determine_visibility (r
);
8564 /* Preserve a typedef that names a type. */
8565 else if (TREE_CODE (r
) == TYPE_DECL
8566 && DECL_ORIGINAL_TYPE (t
)
8567 && type
!= error_mark_node
)
8569 DECL_ORIGINAL_TYPE (r
) = tsubst (DECL_ORIGINAL_TYPE (t
),
8570 args
, complain
, in_decl
);
8571 TREE_TYPE (r
) = type
= build_variant_type_copy (type
);
8572 TYPE_NAME (type
) = r
;
8577 /* A static data member declaration is always marked
8578 external when it is declared in-class, even if an
8579 initializer is present. We mimic the non-template
8581 DECL_EXTERNAL (r
) = 1;
8583 register_specialization (r
, gen_tmpl
, argvec
, false);
8584 DECL_TEMPLATE_INFO (r
) = tree_cons (tmpl
, argvec
, NULL_TREE
);
8585 SET_DECL_IMPLICIT_INSTANTIATION (r
);
8588 register_local_specialization (r
, t
);
8590 TREE_CHAIN (r
) = NULL_TREE
;
8592 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
8593 (int) ATTR_FLAG_TYPE_IN_PLACE
,
8594 args
, complain
, in_decl
);
8603 /* Restore the file and line information. */
8604 input_location
= saved_loc
;
8609 /* Substitute into the ARG_TYPES of a function type. */
8612 tsubst_arg_types (tree arg_types
,
8614 tsubst_flags_t complain
,
8617 tree remaining_arg_types
;
8618 tree type
= NULL_TREE
;
8620 tree expanded_args
= NULL_TREE
;
8623 if (!arg_types
|| arg_types
== void_list_node
)
8626 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
8627 args
, complain
, in_decl
);
8628 if (remaining_arg_types
== error_mark_node
)
8629 return error_mark_node
;
8631 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
8633 /* For a pack expansion, perform substitution on the
8634 entire expression. Later on, we'll handle the arguments
8636 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
8637 args
, complain
, in_decl
);
8639 if (TREE_CODE (expanded_args
) == TREE_VEC
)
8640 /* So that we'll spin through the parameters, one by one. */
8641 i
= TREE_VEC_LENGTH (expanded_args
);
8644 /* We only partially substituted into the parameter
8645 pack. Our type is TYPE_PACK_EXPANSION. */
8646 type
= expanded_args
;
8647 expanded_args
= NULL_TREE
;
8655 type
= TREE_VEC_ELT (expanded_args
, i
);
8657 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
8659 if (type
== error_mark_node
)
8660 return error_mark_node
;
8661 if (VOID_TYPE_P (type
))
8663 if (complain
& tf_error
)
8665 error ("invalid parameter type %qT", type
);
8667 error ("in declaration %q+D", in_decl
);
8669 return error_mark_node
;
8672 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8673 top-level qualifiers as required. */
8674 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
8676 /* We do not substitute into default arguments here. The standard
8677 mandates that they be instantiated only when needed, which is
8678 done in build_over_call. */
8679 default_arg
= TREE_PURPOSE (arg_types
);
8681 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
8683 /* We've instantiated a template before its default arguments
8684 have been parsed. This can happen for a nested template
8685 class, and is not an error unless we require the default
8686 argument in a call of this function. */
8687 remaining_arg_types
=
8688 tree_cons (default_arg
, type
, remaining_arg_types
);
8689 VEC_safe_push (tree
, gc
, DEFARG_INSTANTIATIONS (default_arg
),
8690 remaining_arg_types
);
8693 remaining_arg_types
=
8694 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
8697 return remaining_arg_types
;
8700 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8701 *not* handle the exception-specification for FNTYPE, because the
8702 initial substitution of explicitly provided template parameters
8703 during argument deduction forbids substitution into the
8704 exception-specification:
8708 All references in the function type of the function template to the
8709 corresponding template parameters are replaced by the specified tem-
8710 plate argument values. If a substitution in a template parameter or
8711 in the function type of the function template results in an invalid
8712 type, type deduction fails. [Note: The equivalent substitution in
8713 exception specifications is done only when the function is instanti-
8714 ated, at which point a program is ill-formed if the substitution
8715 results in an invalid type.] */
8718 tsubst_function_type (tree t
,
8720 tsubst_flags_t complain
,
8727 /* The TYPE_CONTEXT is not used for function/method types. */
8728 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
8730 /* Substitute the return type. */
8731 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
8732 if (return_type
== error_mark_node
)
8733 return error_mark_node
;
8734 /* The standard does not presently indicate that creation of a
8735 function type with an invalid return type is a deduction failure.
8736 However, that is clearly analogous to creating an array of "void"
8737 or a reference to a reference. This is core issue #486. */
8738 if (TREE_CODE (return_type
) == ARRAY_TYPE
8739 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
8741 if (complain
& tf_error
)
8743 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
8744 error ("function returning an array");
8746 error ("function returning a function");
8748 return error_mark_node
;
8751 /* Substitute the argument types. */
8752 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
,
8754 if (arg_types
== error_mark_node
)
8755 return error_mark_node
;
8757 if (TYPE_QUALS (return_type
) != TYPE_UNQUALIFIED
8758 && in_decl
!= NULL_TREE
8759 && !TREE_NO_WARNING (in_decl
)
8760 && (SCALAR_TYPE_P (return_type
) || VOID_TYPE_P (return_type
)))
8761 warning (OPT_Wignored_qualifiers
,
8762 "type qualifiers ignored on function return type");
8764 /* Construct a new type node and return it. */
8765 if (TREE_CODE (t
) == FUNCTION_TYPE
)
8766 fntype
= build_function_type (return_type
, arg_types
);
8769 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
8770 if (! MAYBE_CLASS_TYPE_P (r
))
8774 Type deduction may fail for any of the following
8777 -- Attempting to create "pointer to member of T" when T
8778 is not a class type. */
8779 if (complain
& tf_error
)
8780 error ("creating pointer to member function of non-class type %qT",
8782 return error_mark_node
;
8785 fntype
= build_method_type_directly (r
, return_type
,
8786 TREE_CHAIN (arg_types
));
8788 fntype
= cp_build_qualified_type_real (fntype
, TYPE_QUALS (t
), complain
);
8789 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
8794 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8795 ARGS into that specification, and return the substituted
8796 specification. If there is no specification, return NULL_TREE. */
8799 tsubst_exception_specification (tree fntype
,
8801 tsubst_flags_t complain
,
8807 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
8808 new_specs
= NULL_TREE
;
8811 if (! TREE_VALUE (specs
))
8818 tree expanded_specs
= NULL_TREE
;
8820 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
8822 /* Expand the pack expansion type. */
8823 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
8827 if (expanded_specs
== error_mark_node
)
8828 return error_mark_node
;
8829 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
8830 len
= TREE_VEC_LENGTH (expanded_specs
);
8833 /* We're substituting into a member template, so
8834 we got a TYPE_PACK_EXPANSION back. Add that
8835 expansion and move on. */
8836 gcc_assert (TREE_CODE (expanded_specs
)
8837 == TYPE_PACK_EXPANSION
);
8838 new_specs
= add_exception_specifier (new_specs
,
8841 specs
= TREE_CHAIN (specs
);
8846 for (i
= 0; i
< len
; ++i
)
8849 spec
= TREE_VEC_ELT (expanded_specs
, i
);
8851 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
8852 if (spec
== error_mark_node
)
8854 new_specs
= add_exception_specifier (new_specs
, spec
,
8858 specs
= TREE_CHAIN (specs
);
8864 /* Take the tree structure T and replace template parameters used
8865 therein with the argument vector ARGS. IN_DECL is an associated
8866 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8867 Issue error and warning messages under control of COMPLAIN. Note
8868 that we must be relatively non-tolerant of extensions here, in
8869 order to preserve conformance; if we allow substitutions that
8870 should not be allowed, we may allow argument deductions that should
8871 not succeed, and therefore report ambiguous overload situations
8872 where there are none. In theory, we could allow the substitution,
8873 but indicate that it should have failed, and allow our caller to
8874 make sure that the right thing happens, but we don't try to do this
8877 This function is used for dealing with types, decls and the like;
8878 for expressions, use tsubst_expr or tsubst_copy. */
8881 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
8885 if (t
== NULL_TREE
|| t
== error_mark_node
8886 || t
== integer_type_node
8887 || t
== void_type_node
8888 || t
== char_type_node
8889 || t
== unknown_type_node
8890 || TREE_CODE (t
) == NAMESPACE_DECL
)
8894 return tsubst_decl (t
, args
, complain
);
8896 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
8897 type
= IDENTIFIER_TYPE_VALUE (t
);
8899 type
= TREE_TYPE (t
);
8901 gcc_assert (type
!= unknown_type_node
);
8903 /* Reuse typedefs. We need to do this to handle dependent attributes,
8904 such as attribute aligned. */
8907 && TYPE_NAME (t
) != TYPE_MAIN_DECL (t
))
8909 tree decl
= TYPE_NAME (t
);
8911 if (DECL_CLASS_SCOPE_P (decl
)
8912 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
8913 && uses_template_parms (DECL_CONTEXT (decl
)))
8915 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
8916 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
8917 r
= retrieve_specialization (tmpl
, gen_args
, false);
8919 else if (DECL_FUNCTION_SCOPE_P (decl
)
8920 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
8921 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
8922 r
= retrieve_local_specialization (decl
);
8924 /* The typedef is from a non-template context. */
8930 r
= cp_build_qualified_type_real
8931 (r
, cp_type_quals (t
) | cp_type_quals (r
),
8932 complain
| tf_ignore_bad_quals
);
8935 /* Else we must be instantiating the typedef, so fall through. */
8939 && TREE_CODE (t
) != TYPENAME_TYPE
8940 && TREE_CODE (t
) != IDENTIFIER_NODE
8941 && TREE_CODE (t
) != FUNCTION_TYPE
8942 && TREE_CODE (t
) != METHOD_TYPE
)
8943 type
= tsubst (type
, args
, complain
, in_decl
);
8944 if (type
== error_mark_node
)
8945 return error_mark_node
;
8947 switch (TREE_CODE (t
))
8952 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
8953 /*entering_scope=*/0);
8956 case IDENTIFIER_NODE
:
8968 if (t
== integer_type_node
)
8971 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
8972 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
8976 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
8978 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
8979 /*integral_constant_expression_p=*/false);
8980 max
= fold_decl_constant_value (max
);
8982 if (TREE_CODE (max
) != INTEGER_CST
8983 && !at_function_scope_p ()
8984 && !value_dependent_expression_p (max
))
8986 if (complain
& tf_error
)
8987 error ("array bound is not an integer constant");
8988 return error_mark_node
;
8993 Type deduction may fail for any of the following
8996 Attempting to create an array with a size that is
8997 zero or negative. */
8998 if (integer_zerop (max
) && !(complain
& tf_error
))
8999 /* We must fail if performing argument deduction (as
9000 indicated by the state of complain), so that
9001 another substitution can be found. */
9002 return error_mark_node
;
9003 else if (TREE_CODE (max
) == INTEGER_CST
9004 && INT_CST_LT (max
, integer_zero_node
))
9006 if (complain
& tf_error
)
9007 error ("creating array with negative size (%qE)", max
);
9009 return error_mark_node
;
9012 return compute_array_index_type (NULL_TREE
, max
);
9015 case TEMPLATE_TYPE_PARM
:
9016 case TEMPLATE_TEMPLATE_PARM
:
9017 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9018 case TEMPLATE_PARM_INDEX
:
9023 tree arg
= NULL_TREE
;
9027 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
9028 template_parm_level_and_index (t
, &level
, &idx
);
9030 levels
= TMPL_ARGS_DEPTH (args
);
9031 if (level
<= levels
)
9033 arg
= TMPL_ARG (args
, level
, idx
);
9035 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
9036 /* See through ARGUMENT_PACK_SELECT arguments. */
9037 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
9040 if (arg
== error_mark_node
)
9041 return error_mark_node
;
9042 else if (arg
!= NULL_TREE
)
9044 if (ARGUMENT_PACK_P (arg
))
9045 /* If ARG is an argument pack, we don't actually want to
9046 perform a substitution here, because substitutions
9047 for argument packs are only done
9048 element-by-element. We can get to this point when
9049 substituting the type of a non-type template
9050 parameter pack, when that type actually contains
9051 template parameter packs from an outer template, e.g.,
9053 template<typename... Types> struct A {
9054 template<Types... Values> struct B { };
9058 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
9061 gcc_assert (TYPE_P (arg
));
9063 /* cv-quals from the template are discarded when
9064 substituting in a function or reference type. */
9065 if (TREE_CODE (arg
) == FUNCTION_TYPE
9066 || TREE_CODE (arg
) == METHOD_TYPE
9067 || TREE_CODE (arg
) == REFERENCE_TYPE
)
9068 quals
= cp_type_quals (arg
);
9070 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
9072 return cp_build_qualified_type_real
9073 (arg
, quals
, complain
| tf_ignore_bad_quals
);
9075 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
9077 /* We are processing a type constructed from a
9078 template template parameter. */
9079 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
9080 args
, complain
, in_decl
);
9081 if (argvec
== error_mark_node
)
9082 return error_mark_node
;
9084 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9085 are resolving nested-types in the signature of a
9086 member function templates. Otherwise ARG is a
9087 TEMPLATE_DECL and is the real template to be
9089 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
9090 arg
= TYPE_NAME (arg
);
9092 r
= lookup_template_class (arg
,
9095 /*entering_scope=*/0,
9097 return cp_build_qualified_type_real
9098 (r
, TYPE_QUALS (t
), complain
);
9101 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9106 /* This can happen during the attempted tsubst'ing in
9107 unify. This means that we don't yet have any information
9108 about the template parameter in question. */
9111 /* If we get here, we must have been looking at a parm for a
9112 more deeply nested template. Make a new version of this
9113 template parameter, but with a lower level. */
9114 switch (TREE_CODE (t
))
9116 case TEMPLATE_TYPE_PARM
:
9117 case TEMPLATE_TEMPLATE_PARM
:
9118 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9119 if (cp_type_quals (t
))
9121 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
9122 r
= cp_build_qualified_type_real
9123 (r
, cp_type_quals (t
),
9124 complain
| (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
9125 ? tf_ignore_bad_quals
: 0));
9130 TEMPLATE_TYPE_PARM_INDEX (r
)
9131 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
9132 r
, levels
, args
, complain
);
9133 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
9134 TYPE_MAIN_VARIANT (r
) = r
;
9135 TYPE_POINTER_TO (r
) = NULL_TREE
;
9136 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
9138 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
9139 /* We have reduced the level of the template
9140 template parameter, but not the levels of its
9141 template parameters, so canonical_type_parameter
9142 will not be able to find the canonical template
9143 template parameter for this level. Thus, we
9144 require structural equality checking to compare
9145 TEMPLATE_TEMPLATE_PARMs. */
9146 SET_TYPE_STRUCTURAL_EQUALITY (r
);
9147 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
9148 SET_TYPE_STRUCTURAL_EQUALITY (r
);
9150 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
9152 if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
9154 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
9156 if (argvec
== error_mark_node
)
9157 return error_mark_node
;
9159 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
9160 = tree_cons (TYPE_TI_TEMPLATE (t
), argvec
, NULL_TREE
);
9165 case TEMPLATE_PARM_INDEX
:
9166 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
9178 tree purpose
, value
, chain
;
9180 if (t
== void_list_node
)
9183 purpose
= TREE_PURPOSE (t
);
9186 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
9187 if (purpose
== error_mark_node
)
9188 return error_mark_node
;
9190 value
= TREE_VALUE (t
);
9193 value
= tsubst (value
, args
, complain
, in_decl
);
9194 if (value
== error_mark_node
)
9195 return error_mark_node
;
9197 chain
= TREE_CHAIN (t
);
9198 if (chain
&& chain
!= void_type_node
)
9200 chain
= tsubst (chain
, args
, complain
, in_decl
);
9201 if (chain
== error_mark_node
)
9202 return error_mark_node
;
9204 if (purpose
== TREE_PURPOSE (t
)
9205 && value
== TREE_VALUE (t
)
9206 && chain
== TREE_CHAIN (t
))
9208 return hash_tree_cons (purpose
, value
, chain
);
9212 /* We should never be tsubsting a binfo. */
9216 /* A vector of template arguments. */
9218 return tsubst_template_args (t
, args
, complain
, in_decl
);
9221 case REFERENCE_TYPE
:
9223 enum tree_code code
;
9225 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
9228 code
= TREE_CODE (t
);
9233 Type deduction may fail for any of the following
9236 -- Attempting to create a pointer to reference type.
9237 -- Attempting to create a reference to a reference type or
9238 a reference to void.
9240 Core issue 106 says that creating a reference to a reference
9241 during instantiation is no longer a cause for failure. We
9242 only enforce this check in strict C++98 mode. */
9243 if ((TREE_CODE (type
) == REFERENCE_TYPE
9244 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
9245 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
9247 static location_t last_loc
;
9249 /* We keep track of the last time we issued this error
9250 message to avoid spewing a ton of messages during a
9251 single bad template instantiation. */
9252 if (complain
& tf_error
9253 && last_loc
!= input_location
)
9255 if (TREE_CODE (type
) == VOID_TYPE
)
9256 error ("forming reference to void");
9258 error ("forming %s to reference type %qT",
9259 (code
== POINTER_TYPE
) ? "pointer" : "reference",
9261 last_loc
= input_location
;
9264 return error_mark_node
;
9266 else if (code
== POINTER_TYPE
)
9268 r
= build_pointer_type (type
);
9269 if (TREE_CODE (type
) == METHOD_TYPE
)
9270 r
= build_ptrmemfunc_type (r
);
9272 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9273 /* In C++0x, during template argument substitution, when there is an
9274 attempt to create a reference to a reference type, reference
9275 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9277 "If a template-argument for a template-parameter T names a type
9278 that is a reference to a type A, an attempt to create the type
9279 'lvalue reference to cv T' creates the type 'lvalue reference to
9280 A,' while an attempt to create the type type rvalue reference to
9281 cv T' creates the type T"
9283 r
= cp_build_reference_type
9285 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
9287 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
9288 r
= cp_build_qualified_type_real (r
, TYPE_QUALS (t
), complain
);
9290 if (r
!= error_mark_node
)
9291 /* Will this ever be needed for TYPE_..._TO values? */
9298 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
9299 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
9303 Type deduction may fail for any of the following
9306 -- Attempting to create "pointer to member of T" when T
9307 is not a class type. */
9308 if (complain
& tf_error
)
9309 error ("creating pointer to member of non-class type %qT", r
);
9310 return error_mark_node
;
9312 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9314 if (complain
& tf_error
)
9315 error ("creating pointer to member reference type %qT", type
);
9316 return error_mark_node
;
9318 if (TREE_CODE (type
) == VOID_TYPE
)
9320 if (complain
& tf_error
)
9321 error ("creating pointer to member of type void");
9322 return error_mark_node
;
9324 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9325 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9327 /* The type of the implicit object parameter gets its
9328 cv-qualifiers from the FUNCTION_TYPE. */
9330 tree this_type
= cp_build_qualified_type (TYPE_MAIN_VARIANT (r
),
9331 cp_type_quals (type
));
9333 method_type
= build_method_type_directly (this_type
,
9335 TYPE_ARG_TYPES (type
));
9336 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
9337 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
9341 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
9350 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
9351 if (fntype
== error_mark_node
)
9352 return error_mark_node
;
9354 /* Substitute the exception specification. */
9355 specs
= tsubst_exception_specification (t
, args
, complain
,
9357 if (specs
== error_mark_node
)
9358 return error_mark_node
;
9360 fntype
= build_exception_variant (fntype
, specs
);
9365 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
9366 if (domain
== error_mark_node
)
9367 return error_mark_node
;
9369 /* As an optimization, we avoid regenerating the array type if
9370 it will obviously be the same as T. */
9371 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
9374 /* These checks should match the ones in grokdeclarator.
9378 The deduction may fail for any of the following reasons:
9380 -- Attempting to create an array with an element type that
9381 is void, a function type, or a reference type, or [DR337]
9382 an abstract class type. */
9383 if (TREE_CODE (type
) == VOID_TYPE
9384 || TREE_CODE (type
) == FUNCTION_TYPE
9385 || TREE_CODE (type
) == REFERENCE_TYPE
)
9387 if (complain
& tf_error
)
9388 error ("creating array of %qT", type
);
9389 return error_mark_node
;
9391 if (CLASS_TYPE_P (type
) && CLASSTYPE_PURE_VIRTUALS (type
))
9393 if (complain
& tf_error
)
9394 error ("creating array of %qT, which is an abstract class type",
9396 return error_mark_node
;
9399 r
= build_cplus_array_type (type
, domain
);
9401 if (TYPE_USER_ALIGN (t
))
9403 TYPE_ALIGN (r
) = TYPE_ALIGN (t
);
9404 TYPE_USER_ALIGN (r
) = 1;
9413 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9414 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
9416 if (e1
== error_mark_node
|| e2
== error_mark_node
)
9417 return error_mark_node
;
9419 return fold_build2 (TREE_CODE (t
), TREE_TYPE (t
), e1
, e2
);
9425 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9426 if (e
== error_mark_node
)
9427 return error_mark_node
;
9429 return fold_build1 (TREE_CODE (t
), TREE_TYPE (t
), e
);
9434 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
9435 in_decl
, /*entering_scope=*/1);
9436 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
9439 if (ctx
== error_mark_node
|| f
== error_mark_node
)
9440 return error_mark_node
;
9442 if (!MAYBE_CLASS_TYPE_P (ctx
))
9444 if (complain
& tf_error
)
9445 error ("%qT is not a class, struct, or union type", ctx
);
9446 return error_mark_node
;
9448 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
9450 /* Normally, make_typename_type does not require that the CTX
9451 have complete type in order to allow things like:
9453 template <class T> struct S { typename S<T>::X Y; };
9455 But, such constructs have already been resolved by this
9456 point, so here CTX really should have complete type, unless
9457 it's a partial instantiation. */
9458 ctx
= complete_type (ctx
);
9459 if (!COMPLETE_TYPE_P (ctx
))
9461 if (complain
& tf_error
)
9462 cxx_incomplete_type_error (NULL_TREE
, ctx
);
9463 return error_mark_node
;
9467 f
= make_typename_type (ctx
, f
, typename_type
,
9468 (complain
& tf_error
) | tf_keep_type_decl
);
9469 if (f
== error_mark_node
)
9471 if (TREE_CODE (f
) == TYPE_DECL
)
9473 complain
|= tf_ignore_bad_quals
;
9477 if (TREE_CODE (f
) != TYPENAME_TYPE
)
9479 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
9480 error ("%qT resolves to %qT, which is not an enumeration type",
9482 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
9483 error ("%qT resolves to %qT, which is is not a class type",
9487 return cp_build_qualified_type_real
9488 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
9491 case UNBOUND_CLASS_TEMPLATE
:
9493 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
9494 in_decl
, /*entering_scope=*/1);
9495 tree name
= TYPE_IDENTIFIER (t
);
9496 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
9498 if (ctx
== error_mark_node
|| name
== error_mark_node
)
9499 return error_mark_node
;
9502 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
9503 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
9513 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9514 tree e2
= tsubst_expr (TREE_OPERAND (t
, 1), args
, complain
, in_decl
,
9515 /*integral_constant_expression_p=*/false);
9516 if (e1
== error_mark_node
|| e2
== error_mark_node
)
9517 return error_mark_node
;
9519 return build_nt (ARRAY_REF
, e1
, e2
, NULL_TREE
, NULL_TREE
);
9524 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9525 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
9526 if (e1
== error_mark_node
|| e2
== error_mark_node
)
9527 return error_mark_node
;
9529 return build_qualified_name (/*type=*/NULL_TREE
,
9530 e1
, e2
, QUALIFIED_NAME_IS_TEMPLATE (t
));
9537 type
= finish_typeof (tsubst_expr
9538 (TYPEOF_TYPE_EXPR (t
), args
,
9540 /*integral_constant_expression_p=*/false));
9541 return cp_build_qualified_type_real (type
,
9543 | cp_type_quals (type
),
9552 finish_decltype_type (tsubst_expr
9553 (DECLTYPE_TYPE_EXPR (t
), args
,
9555 /*integral_constant_expression_p=*/false),
9556 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
));
9557 return cp_build_qualified_type_real (type
,
9559 | cp_type_quals (type
),
9563 case TYPE_ARGUMENT_PACK
:
9564 case NONTYPE_ARGUMENT_PACK
:
9566 tree r
= make_node (TREE_CODE (t
));
9568 tsubst_template_args (ARGUMENT_PACK_ARGS (t
),
9572 SET_ARGUMENT_PACK_ARGS (r
, packed_out
);
9574 /* For template nontype argument packs, also substitute into
9576 if (TREE_CODE (t
) == NONTYPE_ARGUMENT_PACK
)
9577 TREE_TYPE (r
) = tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
9584 sorry ("use of %qs in template",
9585 tree_code_name
[(int) TREE_CODE (t
)]);
9586 return error_mark_node
;
9590 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9591 type of the expression on the left-hand side of the "." or "->"
9595 tsubst_baselink (tree baselink
, tree object_type
,
9596 tree args
, tsubst_flags_t complain
, tree in_decl
)
9599 tree qualifying_scope
;
9602 tree template_args
= 0;
9603 bool template_id_p
= false;
9605 /* A baselink indicates a function from a base class. Both the
9606 BASELINK_ACCESS_BINFO and the base class referenced may
9607 indicate bases of the template class, rather than the
9608 instantiated class. In addition, lookups that were not
9609 ambiguous before may be ambiguous now. Therefore, we perform
9610 the lookup again. */
9611 qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
9612 qualifying_scope
= tsubst (qualifying_scope
, args
,
9614 fns
= BASELINK_FUNCTIONS (baselink
);
9615 optype
= BASELINK_OPTYPE (baselink
);
9616 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
9618 template_id_p
= true;
9619 template_args
= TREE_OPERAND (fns
, 1);
9620 fns
= TREE_OPERAND (fns
, 0);
9622 template_args
= tsubst_template_args (template_args
, args
,
9625 name
= DECL_NAME (get_first_fn (fns
));
9626 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
9628 /* If lookup found a single function, mark it as used at this
9629 point. (If it lookup found multiple functions the one selected
9630 later by overload resolution will be marked as used at that
9632 if (BASELINK_P (baselink
))
9633 fns
= BASELINK_FUNCTIONS (baselink
);
9634 if (!template_id_p
&& !really_overloaded_fn (fns
))
9635 mark_used (OVL_CURRENT (fns
));
9637 /* Add back the template arguments, if present. */
9638 if (BASELINK_P (baselink
) && template_id_p
)
9639 BASELINK_FUNCTIONS (baselink
)
9640 = build_nt (TEMPLATE_ID_EXPR
,
9641 BASELINK_FUNCTIONS (baselink
),
9643 /* Update the conversion operator type. */
9644 BASELINK_OPTYPE (baselink
)
9645 = tsubst (optype
, args
, complain
, in_decl
);
9648 object_type
= current_class_type
;
9649 return adjust_result_of_qualified_name_lookup (baselink
,
9654 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9655 true if the qualified-id will be a postfix-expression in-and-of
9656 itself; false if more of the postfix-expression follows the
9657 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9661 tsubst_qualified_id (tree qualified_id
, tree args
,
9662 tsubst_flags_t complain
, tree in_decl
,
9663 bool done
, bool address_p
)
9671 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
9673 /* Figure out what name to look up. */
9674 name
= TREE_OPERAND (qualified_id
, 1);
9675 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
9678 template_args
= TREE_OPERAND (name
, 1);
9680 template_args
= tsubst_template_args (template_args
, args
,
9682 name
= TREE_OPERAND (name
, 0);
9686 is_template
= false;
9687 template_args
= NULL_TREE
;
9690 /* Substitute into the qualifying scope. When there are no ARGS, we
9691 are just trying to simplify a non-dependent expression. In that
9692 case the qualifying scope may be dependent, and, in any case,
9693 substituting will not help. */
9694 scope
= TREE_OPERAND (qualified_id
, 0);
9697 scope
= tsubst (scope
, args
, complain
, in_decl
);
9698 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
9703 if (dependent_type_p (scope
))
9704 return build_qualified_name (/*type=*/NULL_TREE
,
9706 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
9708 if (!BASELINK_P (name
) && !DECL_P (expr
))
9710 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
9711 /* If this were actually a destructor call, it would have been
9712 parsed as such by the parser. */
9713 expr
= error_mark_node
;
9715 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
9716 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
9717 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
9719 if (complain
& tf_error
)
9721 error ("dependent-name %qE is parsed as a non-type, but "
9722 "instantiation yields a type", qualified_id
);
9723 inform ("say %<typename %E%> if a type is meant", qualified_id
);
9725 return error_mark_node
;
9731 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
9733 /* Remember that there was a reference to this entity. */
9737 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
9739 if (complain
& tf_error
)
9740 qualified_name_lookup_error (scope
,
9741 TREE_OPERAND (qualified_id
, 1),
9743 return error_mark_node
;
9747 expr
= lookup_template_function (expr
, template_args
);
9749 if (expr
== error_mark_node
&& complain
& tf_error
)
9750 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
9752 else if (TYPE_P (scope
))
9754 expr
= (adjust_result_of_qualified_name_lookup
9755 (expr
, scope
, current_class_type
));
9756 expr
= (finish_qualified_id_expr
9757 (scope
, expr
, done
, address_p
,
9758 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
9759 /*template_arg_p=*/false));
9762 /* Expressions do not generally have reference type. */
9763 if (TREE_CODE (expr
) != SCOPE_REF
9764 /* However, if we're about to form a pointer-to-member, we just
9765 want the referenced member referenced. */
9766 && TREE_CODE (expr
) != OFFSET_REF
)
9767 expr
= convert_from_reference (expr
);
9772 /* Like tsubst, but deals with expressions. This function just replaces
9773 template parms; to finish processing the resultant expression, use
9777 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
9779 enum tree_code code
;
9782 if (t
== NULL_TREE
|| t
== error_mark_node
)
9785 code
= TREE_CODE (t
);
9790 r
= retrieve_local_specialization (t
);
9791 gcc_assert (r
!= NULL
);
9792 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
9793 r
= ARGUMENT_PACK_SELECT_ARG (r
);
9802 if (DECL_TEMPLATE_PARM_P (t
))
9803 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
9804 /* There is no need to substitute into namespace-scope
9806 if (DECL_NAMESPACE_SCOPE_P (t
))
9808 /* If ARGS is NULL, then T is known to be non-dependent. */
9809 if (args
== NULL_TREE
)
9810 return integral_constant_value (t
);
9812 /* Unfortunately, we cannot just call lookup_name here.
9815 template <int I> int f() {
9817 struct S { void g() { E e = a; } };
9820 When we instantiate f<7>::S::g(), say, lookup_name is not
9821 clever enough to find f<7>::a. */
9823 = tsubst_aggr_type (TREE_TYPE (t
), args
, complain
, in_decl
,
9824 /*entering_scope=*/0);
9826 for (v
= TYPE_VALUES (enum_type
);
9829 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
9830 return TREE_VALUE (v
);
9832 /* We didn't find the name. That should never happen; if
9833 name-lookup found it during preliminary parsing, we
9834 should find it again here during instantiation. */
9840 if (DECL_CONTEXT (t
))
9844 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
9845 /*entering_scope=*/1);
9846 if (ctx
!= DECL_CONTEXT (t
))
9848 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
9851 if (complain
& tf_error
)
9852 error ("using invalid field %qD", t
);
9853 return error_mark_node
;
9863 if ((DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9864 || local_variable_p (t
))
9865 t
= tsubst (t
, args
, complain
, in_decl
);
9870 return tsubst_baselink (t
, current_class_type
, args
, complain
, in_decl
);
9873 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9874 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
9875 args
, complain
, in_decl
);
9876 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
9877 return tsubst (t
, args
, complain
, in_decl
);
9878 else if (DECL_CLASS_SCOPE_P (t
)
9879 && uses_template_parms (DECL_CONTEXT (t
)))
9881 /* Template template argument like the following example need
9884 template <template <class> class TT> struct C {};
9885 template <class T> struct D {
9886 template <class U> struct E {};
9891 We are processing the template argument `E' in #1 for
9892 the template instantiation #2. Originally, `E' is a
9893 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9894 have to substitute this with one having context `D<int>'. */
9896 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
9897 return lookup_field (context
, DECL_NAME(t
), 0, false);
9900 /* Ordinary template template argument. */
9904 case REINTERPRET_CAST_EXPR
:
9905 case CONST_CAST_EXPR
:
9906 case STATIC_CAST_EXPR
:
9907 case DYNAMIC_CAST_EXPR
:
9910 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
9911 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
9914 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
9916 /* We only want to compute the number of arguments. */
9917 tree expanded
= tsubst_pack_expansion (TREE_OPERAND (t
, 0), args
,
9921 if (TREE_CODE (expanded
) == TREE_VEC
)
9922 len
= TREE_VEC_LENGTH (expanded
);
9924 if (expanded
== error_mark_node
)
9925 return error_mark_node
;
9926 else if (PACK_EXPANSION_P (expanded
)
9927 || (TREE_CODE (expanded
) == TREE_VEC
9929 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded
, len
-1))))
9931 if (TREE_CODE (expanded
) == TREE_VEC
)
9932 expanded
= TREE_VEC_ELT (expanded
, len
- 1);
9934 if (TYPE_P (expanded
))
9935 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
9936 complain
& tf_error
);
9938 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
9939 complain
& tf_error
);
9942 return build_int_cst (size_type_node
, len
);
9948 case TRUTH_NOT_EXPR
:
9951 case UNARY_PLUS_EXPR
: /* Unary + */
9959 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
9960 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
9967 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
9968 name
= TREE_OPERAND (t
, 1);
9969 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
9971 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9973 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
9975 else if (TREE_CODE (name
) == SCOPE_REF
9976 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
9978 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9980 name
= TREE_OPERAND (name
, 1);
9981 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
9983 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
9984 name
= build_qualified_name (/*type=*/NULL_TREE
,
9986 /*template_p=*/false);
9988 else if (TREE_CODE (name
) == BASELINK
)
9989 name
= tsubst_baselink (name
,
9990 non_reference (TREE_TYPE (object
)),
9994 name
= tsubst_copy (name
, args
, complain
, in_decl
);
9995 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
10001 case TRUNC_DIV_EXPR
:
10002 case CEIL_DIV_EXPR
:
10003 case FLOOR_DIV_EXPR
:
10004 case ROUND_DIV_EXPR
:
10005 case EXACT_DIV_EXPR
:
10009 case TRUNC_MOD_EXPR
:
10010 case FLOOR_MOD_EXPR
:
10011 case TRUTH_ANDIF_EXPR
:
10012 case TRUTH_ORIF_EXPR
:
10013 case TRUTH_AND_EXPR
:
10014 case TRUTH_OR_EXPR
:
10027 case COMPOUND_EXPR
:
10030 case PREDECREMENT_EXPR
:
10031 case PREINCREMENT_EXPR
:
10032 case POSTDECREMENT_EXPR
:
10033 case POSTINCREMENT_EXPR
:
10035 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10036 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
10039 return build_qualified_name (/*type=*/NULL_TREE
,
10040 tsubst_copy (TREE_OPERAND (t
, 0),
10041 args
, complain
, in_decl
),
10042 tsubst_copy (TREE_OPERAND (t
, 1),
10043 args
, complain
, in_decl
),
10044 QUALIFIED_NAME_IS_TEMPLATE (t
));
10049 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10050 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
10051 NULL_TREE
, NULL_TREE
);
10055 int n
= VL_EXP_OPERAND_LENGTH (t
);
10056 tree result
= build_vl_exp (CALL_EXPR
, n
);
10058 for (i
= 0; i
< n
; i
++)
10059 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
10060 complain
, in_decl
);
10066 case PSEUDO_DTOR_EXPR
:
10069 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10070 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
10071 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
10072 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
10079 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10080 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
10081 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
10082 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
10089 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
10090 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
10091 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
10092 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
10096 case TEMPLATE_ID_EXPR
:
10098 /* Substituted template arguments */
10099 tree fn
= TREE_OPERAND (t
, 0);
10100 tree targs
= TREE_OPERAND (t
, 1);
10102 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
10104 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
10106 return lookup_template_function (fn
, targs
);
10111 tree purpose
, value
, chain
;
10113 if (t
== void_list_node
)
10116 purpose
= TREE_PURPOSE (t
);
10118 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
10119 value
= TREE_VALUE (t
);
10121 value
= tsubst_copy (value
, args
, complain
, in_decl
);
10122 chain
= TREE_CHAIN (t
);
10123 if (chain
&& chain
!= void_type_node
)
10124 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
10125 if (purpose
== TREE_PURPOSE (t
)
10126 && value
== TREE_VALUE (t
)
10127 && chain
== TREE_CHAIN (t
))
10129 return tree_cons (purpose
, value
, chain
);
10134 case ENUMERAL_TYPE
:
10136 case TEMPLATE_TYPE_PARM
:
10137 case TEMPLATE_TEMPLATE_PARM
:
10138 case BOUND_TEMPLATE_TEMPLATE_PARM
:
10139 case TEMPLATE_PARM_INDEX
:
10141 case REFERENCE_TYPE
:
10143 case FUNCTION_TYPE
:
10146 case TYPENAME_TYPE
:
10147 case UNBOUND_CLASS_TEMPLATE
:
10149 case DECLTYPE_TYPE
:
10151 return tsubst (t
, args
, complain
, in_decl
);
10153 case IDENTIFIER_NODE
:
10154 if (IDENTIFIER_TYPENAME_P (t
))
10156 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10157 return mangle_conv_op_name_for_type (new_type
);
10163 /* This is handled by tsubst_copy_and_build. */
10164 gcc_unreachable ();
10167 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
10169 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
10171 case CLEANUP_POINT_EXPR
:
10172 /* We shouldn't have built any of these during initial template
10173 generation. Instead, they should be built during instantiation
10174 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10175 gcc_unreachable ();
10178 mark_used (TREE_OPERAND (t
, 1));
10181 case EXPR_PACK_EXPANSION
:
10182 error ("invalid use of pack expansion expression");
10183 return error_mark_node
;
10185 case NONTYPE_ARGUMENT_PACK
:
10186 error ("use %<...%> to expand argument pack");
10187 return error_mark_node
;
10194 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10197 tsubst_omp_clauses (tree clauses
, tree args
, tsubst_flags_t complain
,
10200 tree new_clauses
= NULL
, nc
, oc
;
10202 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
10204 nc
= copy_node (oc
);
10205 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
10208 switch (OMP_CLAUSE_CODE (nc
))
10210 case OMP_CLAUSE_PRIVATE
:
10211 case OMP_CLAUSE_SHARED
:
10212 case OMP_CLAUSE_FIRSTPRIVATE
:
10213 case OMP_CLAUSE_LASTPRIVATE
:
10214 case OMP_CLAUSE_REDUCTION
:
10215 case OMP_CLAUSE_COPYIN
:
10216 case OMP_CLAUSE_COPYPRIVATE
:
10217 case OMP_CLAUSE_IF
:
10218 case OMP_CLAUSE_NUM_THREADS
:
10219 case OMP_CLAUSE_SCHEDULE
:
10220 OMP_CLAUSE_OPERAND (nc
, 0)
10221 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
10222 in_decl
, /*integral_constant_expression_p=*/false);
10224 case OMP_CLAUSE_NOWAIT
:
10225 case OMP_CLAUSE_ORDERED
:
10226 case OMP_CLAUSE_DEFAULT
:
10229 gcc_unreachable ();
10233 return finish_omp_clauses (nreverse (new_clauses
));
10236 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10239 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
10242 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10244 tree purpose
, value
, chain
;
10249 if (TREE_CODE (t
) != TREE_LIST
)
10250 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
10251 /*function_p=*/false,
10252 /*integral_constant_expression_p=*/false);
10254 if (t
== void_list_node
)
10257 purpose
= TREE_PURPOSE (t
);
10259 purpose
= RECUR (purpose
);
10260 value
= TREE_VALUE (t
);
10262 value
= RECUR (value
);
10263 chain
= TREE_CHAIN (t
);
10264 if (chain
&& chain
!= void_type_node
)
10265 chain
= RECUR (chain
);
10266 return tree_cons (purpose
, value
, chain
);
10270 /* Like tsubst_copy for expressions, etc. but also does semantic
10274 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
10275 bool integral_constant_expression_p
)
10277 #define RECUR(NODE) \
10278 tsubst_expr ((NODE), args, complain, in_decl, \
10279 integral_constant_expression_p)
10283 if (t
== NULL_TREE
|| t
== error_mark_node
)
10286 if (EXPR_HAS_LOCATION (t
))
10287 input_location
= EXPR_LOCATION (t
);
10288 if (STATEMENT_CODE_P (TREE_CODE (t
)))
10289 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
10291 switch (TREE_CODE (t
))
10293 case STATEMENT_LIST
:
10295 tree_stmt_iterator i
;
10296 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
10297 RECUR (tsi_stmt (i
));
10301 case CTOR_INITIALIZER
:
10302 finish_mem_initializers (tsubst_initializer_list
10303 (TREE_OPERAND (t
, 0), args
));
10307 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
10311 tmp
= RECUR (EXPR_STMT_EXPR (t
));
10312 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
10313 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
10315 finish_expr_stmt (tmp
);
10319 do_using_directive (RECUR (USING_STMT_NAMESPACE (t
)));
10327 decl
= DECL_EXPR_DECL (t
);
10328 if (TREE_CODE (decl
) == LABEL_DECL
)
10329 finish_label_decl (DECL_NAME (decl
));
10330 else if (TREE_CODE (decl
) == USING_DECL
)
10332 tree scope
= USING_DECL_SCOPE (decl
);
10333 tree name
= DECL_NAME (decl
);
10336 scope
= RECUR (scope
);
10337 decl
= lookup_qualified_name (scope
, name
,
10338 /*is_type_p=*/false,
10339 /*complain=*/false);
10340 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
10341 qualified_name_lookup_error (scope
, name
, decl
);
10343 do_local_using_decl (decl
, scope
, name
);
10347 init
= DECL_INITIAL (decl
);
10348 decl
= tsubst (decl
, args
, complain
, in_decl
);
10349 if (decl
!= error_mark_node
)
10351 /* By marking the declaration as instantiated, we avoid
10352 trying to instantiate it. Since instantiate_decl can't
10353 handle local variables, and since we've already done
10354 all that needs to be done, that's the right thing to
10356 if (TREE_CODE (decl
) == VAR_DECL
)
10357 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
10358 if (TREE_CODE (decl
) == VAR_DECL
10359 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
10360 /* Anonymous aggregates are a special case. */
10361 finish_anon_union (decl
);
10364 maybe_push_decl (decl
);
10365 if (TREE_CODE (decl
) == VAR_DECL
10366 && DECL_PRETTY_FUNCTION_P (decl
))
10368 /* For __PRETTY_FUNCTION__ we have to adjust the
10370 const char *const name
10371 = cxx_printable_name (current_function_decl
, 2);
10372 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
10376 tree t
= RECUR (init
);
10379 /* If we had an initializer but it
10380 instantiated to nothing,
10381 value-initialize the object. This will
10382 only occur when the initializer was a
10383 pack expansion where the parameter packs
10384 used in that expansion were of length
10386 init
= build_default_init (TREE_TYPE (decl
),
10392 finish_decl (decl
, init
, NULL_TREE
);
10397 /* A DECL_EXPR can also be used as an expression, in the condition
10398 clause of an if/for/while construct. */
10403 stmt
= begin_for_stmt ();
10404 RECUR (FOR_INIT_STMT (t
));
10405 finish_for_init_stmt (stmt
);
10406 tmp
= RECUR (FOR_COND (t
));
10407 finish_for_cond (tmp
, stmt
);
10408 tmp
= RECUR (FOR_EXPR (t
));
10409 finish_for_expr (tmp
, stmt
);
10410 RECUR (FOR_BODY (t
));
10411 finish_for_stmt (stmt
);
10415 stmt
= begin_while_stmt ();
10416 tmp
= RECUR (WHILE_COND (t
));
10417 finish_while_stmt_cond (tmp
, stmt
);
10418 RECUR (WHILE_BODY (t
));
10419 finish_while_stmt (stmt
);
10423 stmt
= begin_do_stmt ();
10424 RECUR (DO_BODY (t
));
10425 finish_do_body (stmt
);
10426 tmp
= RECUR (DO_COND (t
));
10427 finish_do_stmt (tmp
, stmt
);
10431 stmt
= begin_if_stmt ();
10432 tmp
= RECUR (IF_COND (t
));
10433 finish_if_stmt_cond (tmp
, stmt
);
10434 RECUR (THEN_CLAUSE (t
));
10435 finish_then_clause (stmt
);
10437 if (ELSE_CLAUSE (t
))
10439 begin_else_clause (stmt
);
10440 RECUR (ELSE_CLAUSE (t
));
10441 finish_else_clause (stmt
);
10444 finish_if_stmt (stmt
);
10448 if (BIND_EXPR_BODY_BLOCK (t
))
10449 stmt
= begin_function_body ();
10451 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
10452 ? BCS_TRY_BLOCK
: 0);
10454 RECUR (BIND_EXPR_BODY (t
));
10456 if (BIND_EXPR_BODY_BLOCK (t
))
10457 finish_function_body (stmt
);
10459 finish_compound_stmt (stmt
);
10463 finish_break_stmt ();
10466 case CONTINUE_STMT
:
10467 finish_continue_stmt ();
10471 stmt
= begin_switch_stmt ();
10472 tmp
= RECUR (SWITCH_STMT_COND (t
));
10473 finish_switch_cond (tmp
, stmt
);
10474 RECUR (SWITCH_STMT_BODY (t
));
10475 finish_switch_stmt (stmt
);
10478 case CASE_LABEL_EXPR
:
10479 finish_case_label (RECUR (CASE_LOW (t
)),
10480 RECUR (CASE_HIGH (t
)));
10484 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t
)));
10488 tmp
= GOTO_DESTINATION (t
);
10489 if (TREE_CODE (tmp
) != LABEL_DECL
)
10490 /* Computed goto's must be tsubst'd into. On the other hand,
10491 non-computed gotos must not be; the identifier in question
10492 will have no binding. */
10495 tmp
= DECL_NAME (tmp
);
10496 finish_goto_stmt (tmp
);
10500 tmp
= finish_asm_stmt
10501 (ASM_VOLATILE_P (t
),
10502 RECUR (ASM_STRING (t
)),
10503 tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
10504 tsubst_copy_asm_operands (ASM_INPUTS (t
), args
, complain
, in_decl
),
10505 tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
, complain
, in_decl
));
10507 tree asm_expr
= tmp
;
10508 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
10509 asm_expr
= TREE_OPERAND (asm_expr
, 0);
10510 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
10517 stmt
= begin_try_block ();
10518 RECUR (TRY_STMTS (t
));
10519 finish_cleanup_try_block (stmt
);
10520 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
10524 tree compound_stmt
= NULL_TREE
;
10526 if (FN_TRY_BLOCK_P (t
))
10527 stmt
= begin_function_try_block (&compound_stmt
);
10529 stmt
= begin_try_block ();
10531 RECUR (TRY_STMTS (t
));
10533 if (FN_TRY_BLOCK_P (t
))
10534 finish_function_try_block (stmt
);
10536 finish_try_block (stmt
);
10538 RECUR (TRY_HANDLERS (t
));
10539 if (FN_TRY_BLOCK_P (t
))
10540 finish_function_handler_sequence (stmt
, compound_stmt
);
10542 finish_handler_sequence (stmt
);
10548 tree decl
= HANDLER_PARMS (t
);
10552 decl
= tsubst (decl
, args
, complain
, in_decl
);
10553 /* Prevent instantiate_decl from trying to instantiate
10554 this variable. We've already done all that needs to be
10556 if (decl
!= error_mark_node
)
10557 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
10559 stmt
= begin_handler ();
10560 finish_handler_parms (decl
, stmt
);
10561 RECUR (HANDLER_BODY (t
));
10562 finish_handler (stmt
);
10567 tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
10570 case STATIC_ASSERT
:
10573 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
10576 /*integral_constant_expression_p=*/true);
10577 finish_static_assert (condition
,
10578 STATIC_ASSERT_MESSAGE (t
),
10579 STATIC_ASSERT_SOURCE_LOCATION (t
),
10580 /*member_p=*/false);
10585 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
),
10586 args
, complain
, in_decl
);
10587 stmt
= begin_omp_parallel ();
10588 RECUR (OMP_PARALLEL_BODY (t
));
10589 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
10590 = OMP_PARALLEL_COMBINED (t
);
10595 tree clauses
, decl
, init
, cond
, incr
, body
, pre_body
;
10597 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
),
10598 args
, complain
, in_decl
);
10599 init
= OMP_FOR_INIT (t
);
10600 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
10601 decl
= RECUR (TREE_OPERAND (init
, 0));
10602 init
= RECUR (TREE_OPERAND (init
, 1));
10603 cond
= RECUR (OMP_FOR_COND (t
));
10604 incr
= RECUR (OMP_FOR_INCR (t
));
10606 stmt
= begin_omp_structured_block ();
10608 pre_body
= push_stmt_list ();
10609 RECUR (OMP_FOR_PRE_BODY (t
));
10610 pre_body
= pop_stmt_list (pre_body
);
10612 body
= push_stmt_list ();
10613 RECUR (OMP_FOR_BODY (t
));
10614 body
= pop_stmt_list (body
);
10616 t
= finish_omp_for (EXPR_LOCATION (t
), decl
, init
, cond
, incr
, body
,
10619 OMP_FOR_CLAUSES (t
) = clauses
;
10621 add_stmt (finish_omp_structured_block (stmt
));
10627 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), args
, complain
, in_decl
);
10628 stmt
= push_stmt_list ();
10629 RECUR (OMP_BODY (t
));
10630 stmt
= pop_stmt_list (stmt
);
10633 OMP_BODY (t
) = stmt
;
10634 OMP_CLAUSES (t
) = tmp
;
10642 stmt
= push_stmt_list ();
10643 RECUR (OMP_BODY (t
));
10644 stmt
= pop_stmt_list (stmt
);
10647 OMP_BODY (t
) = stmt
;
10652 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
10654 tree op1
= TREE_OPERAND (t
, 1);
10655 tree lhs
= RECUR (TREE_OPERAND (op1
, 0));
10656 tree rhs
= RECUR (TREE_OPERAND (op1
, 1));
10657 finish_omp_atomic (TREE_CODE (op1
), lhs
, rhs
);
10661 case EXPR_PACK_EXPANSION
:
10662 error ("invalid use of pack expansion expression");
10663 return error_mark_node
;
10665 case NONTYPE_ARGUMENT_PACK
:
10666 error ("use %<...%> to expand argument pack");
10667 return error_mark_node
;
10670 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
10672 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
10673 /*function_p=*/false,
10674 integral_constant_expression_p
);
10681 /* T is a postfix-expression that is not being used in a function
10682 call. Return the substituted version of T. */
10685 tsubst_non_call_postfix_expression (tree t
, tree args
,
10686 tsubst_flags_t complain
,
10689 if (TREE_CODE (t
) == SCOPE_REF
)
10690 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
10691 /*done=*/false, /*address_p=*/false);
10693 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
10694 /*function_p=*/false,
10695 /*integral_constant_expression_p=*/false);
10700 /* Like tsubst but deals with expressions and performs semantic
10701 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10704 tsubst_copy_and_build (tree t
,
10706 tsubst_flags_t complain
,
10709 bool integral_constant_expression_p
)
10711 #define RECUR(NODE) \
10712 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10713 /*function_p=*/false, \
10714 integral_constant_expression_p)
10718 if (t
== NULL_TREE
|| t
== error_mark_node
)
10721 switch (TREE_CODE (t
))
10725 /* Fall through. */
10726 case IDENTIFIER_NODE
:
10730 bool non_integral_constant_expression_p
;
10731 const char *error_msg
;
10733 if (IDENTIFIER_TYPENAME_P (t
))
10735 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10736 t
= mangle_conv_op_name_for_type (new_type
);
10739 /* Look up the name. */
10740 decl
= lookup_name (t
);
10742 /* By convention, expressions use ERROR_MARK_NODE to indicate
10743 failure, not NULL_TREE. */
10744 if (decl
== NULL_TREE
)
10745 decl
= error_mark_node
;
10747 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
10749 integral_constant_expression_p
,
10750 /*allow_non_integral_constant_expression_p=*/false,
10751 &non_integral_constant_expression_p
,
10752 /*template_p=*/false,
10754 /*address_p=*/false,
10755 /*template_arg_p=*/false,
10759 if (!function_p
&& TREE_CODE (decl
) == IDENTIFIER_NODE
)
10760 decl
= unqualified_name_lookup_error (decl
);
10764 case TEMPLATE_ID_EXPR
:
10767 tree
template = RECUR (TREE_OPERAND (t
, 0));
10768 tree targs
= TREE_OPERAND (t
, 1);
10771 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
10773 if (TREE_CODE (template) == COMPONENT_REF
)
10775 object
= TREE_OPERAND (template, 0);
10776 template = TREE_OPERAND (template, 1);
10779 object
= NULL_TREE
;
10780 template = lookup_template_function (template, targs
);
10783 return build3 (COMPONENT_REF
, TREE_TYPE (template),
10784 object
, template, NULL_TREE
);
10786 return baselink_for_fns (template);
10791 tree r
= RECUR (TREE_OPERAND (t
, 0));
10793 if (REFERENCE_REF_P (t
))
10795 /* A type conversion to reference type will be enclosed in
10796 such an indirect ref, but the substitution of the cast
10797 will have also added such an indirect ref. */
10798 if (TREE_CODE (TREE_TYPE (r
)) == REFERENCE_TYPE
)
10799 r
= convert_from_reference (r
);
10802 r
= build_x_indirect_ref (r
, "unary *", complain
);
10808 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
10809 RECUR (TREE_OPERAND (t
, 0)));
10812 case REINTERPRET_CAST_EXPR
:
10813 case CONST_CAST_EXPR
:
10814 case DYNAMIC_CAST_EXPR
:
10815 case STATIC_CAST_EXPR
:
10820 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
10821 if (integral_constant_expression_p
10822 && !cast_valid_in_integral_constant_expression_p (type
))
10824 if (complain
& tf_error
)
10825 error ("a cast to a type other than an integral or "
10826 "enumeration type cannot appear in a constant-expression");
10827 return error_mark_node
;
10830 op
= RECUR (TREE_OPERAND (t
, 0));
10832 switch (TREE_CODE (t
))
10835 return build_functional_cast (type
, op
, complain
);
10836 case REINTERPRET_CAST_EXPR
:
10837 return build_reinterpret_cast (type
, op
, complain
);
10838 case CONST_CAST_EXPR
:
10839 return build_const_cast (type
, op
, complain
);
10840 case DYNAMIC_CAST_EXPR
:
10841 return build_dynamic_cast (type
, op
, complain
);
10842 case STATIC_CAST_EXPR
:
10843 return build_static_cast (type
, op
, complain
);
10845 gcc_unreachable ();
10849 case POSTDECREMENT_EXPR
:
10850 case POSTINCREMENT_EXPR
:
10851 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10852 args
, complain
, in_decl
);
10853 return build_x_unary_op (TREE_CODE (t
), op1
, complain
);
10855 case PREDECREMENT_EXPR
:
10856 case PREINCREMENT_EXPR
:
10860 case TRUTH_NOT_EXPR
:
10861 case UNARY_PLUS_EXPR
: /* Unary + */
10862 case REALPART_EXPR
:
10863 case IMAGPART_EXPR
:
10864 return build_x_unary_op (TREE_CODE (t
), RECUR (TREE_OPERAND (t
, 0)),
10868 op1
= TREE_OPERAND (t
, 0);
10869 if (TREE_CODE (op1
) == SCOPE_REF
)
10870 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
10871 /*done=*/true, /*address_p=*/true);
10873 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
10875 if (TREE_CODE (op1
) == LABEL_DECL
)
10876 return finish_label_address_expr (DECL_NAME (op1
));
10877 return build_x_unary_op (ADDR_EXPR
, op1
, complain
);
10882 case TRUNC_DIV_EXPR
:
10883 case CEIL_DIV_EXPR
:
10884 case FLOOR_DIV_EXPR
:
10885 case ROUND_DIV_EXPR
:
10886 case EXACT_DIV_EXPR
:
10890 case TRUNC_MOD_EXPR
:
10891 case FLOOR_MOD_EXPR
:
10892 case TRUTH_ANDIF_EXPR
:
10893 case TRUTH_ORIF_EXPR
:
10894 case TRUTH_AND_EXPR
:
10895 case TRUTH_OR_EXPR
:
10910 return build_x_binary_op
10912 RECUR (TREE_OPERAND (t
, 0)),
10913 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
10915 : TREE_CODE (TREE_OPERAND (t
, 0))),
10916 RECUR (TREE_OPERAND (t
, 1)),
10917 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
10919 : TREE_CODE (TREE_OPERAND (t
, 1))),
10920 /*overloaded_p=*/NULL
,
10924 return tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
10925 /*address_p=*/false);
10927 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10928 args
, complain
, in_decl
);
10929 return build_x_binary_op (ARRAY_REF
, op1
,
10930 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
10932 : TREE_CODE (TREE_OPERAND (t
, 0))),
10933 RECUR (TREE_OPERAND (t
, 1)),
10934 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
10936 : TREE_CODE (TREE_OPERAND (t
, 1))),
10937 /*overloaded_p=*/NULL
,
10941 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0)))
10942 return tsubst_copy (t
, args
, complain
, in_decl
);
10946 op1
= TREE_OPERAND (t
, 0);
10949 /* When there are no ARGS, we are trying to evaluate a
10950 non-dependent expression from the parser. Trying to do
10951 the substitutions may not work. */
10953 op1
= TREE_TYPE (op1
);
10958 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
10959 /*function_p=*/false,
10960 /*integral_constant_expression_p=*/false);
10964 return cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
10965 complain
& tf_error
);
10967 return cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
10968 complain
& tf_error
);
10972 tree r
= build_x_modify_expr
10973 (RECUR (TREE_OPERAND (t
, 0)),
10974 TREE_CODE (TREE_OPERAND (t
, 1)),
10975 RECUR (TREE_OPERAND (t
, 2)),
10977 /* TREE_NO_WARNING must be set if either the expression was
10978 parenthesized or it uses an operator such as >>= rather
10979 than plain assignment. In the former case, it was already
10980 set and must be copied. In the latter case,
10981 build_x_modify_expr sets it and it must not be reset
10983 if (TREE_NO_WARNING (t
))
10984 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
10989 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
10990 args
, complain
, in_decl
);
10991 /* Remember that there was a reference to this entity. */
10994 return build_x_arrow (op1
);
10998 tree init
= RECUR (TREE_OPERAND (t
, 3));
11000 if (TREE_OPERAND (t
, 3) && !init
)
11001 /* If there was an initializer in the the original tree, but
11002 it instantiated to an empty list, then we should pass on
11003 VOID_ZERO_NODE to tell build_new that it was an empty
11004 initializer () rather than no initializer. This can only
11005 happen when the initializer is a pack expansion whose
11006 parameter packs are of length zero. */
11007 init
= void_zero_node
;
11010 (RECUR (TREE_OPERAND (t
, 0)),
11011 RECUR (TREE_OPERAND (t
, 1)),
11012 RECUR (TREE_OPERAND (t
, 2)),
11014 NEW_EXPR_USE_GLOBAL (t
),
11019 return delete_sanity
11020 (RECUR (TREE_OPERAND (t
, 0)),
11021 RECUR (TREE_OPERAND (t
, 1)),
11022 DELETE_EXPR_USE_VEC (t
),
11023 DELETE_EXPR_USE_GLOBAL (t
));
11025 case COMPOUND_EXPR
:
11026 return build_x_compound_expr (RECUR (TREE_OPERAND (t
, 0)),
11027 RECUR (TREE_OPERAND (t
, 1)),
11037 function
= CALL_EXPR_FN (t
);
11038 /* When we parsed the expression, we determined whether or
11039 not Koenig lookup should be performed. */
11040 koenig_p
= KOENIG_LOOKUP_P (t
);
11041 if (TREE_CODE (function
) == SCOPE_REF
)
11043 qualified_p
= true;
11044 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
11046 /*address_p=*/false);
11050 if (TREE_CODE (function
) == COMPONENT_REF
)
11052 tree op
= TREE_OPERAND (function
, 1);
11054 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
11055 || (BASELINK_P (op
)
11056 && BASELINK_QUALIFIED_P (op
)));
11059 qualified_p
= false;
11061 function
= tsubst_copy_and_build (function
, args
, complain
,
11064 integral_constant_expression_p
);
11066 if (BASELINK_P (function
))
11067 qualified_p
= true;
11070 /* FIXME: Rewrite this so as not to construct an arglist. */
11071 call_args
= RECUR (CALL_EXPR_ARGS (t
));
11073 /* We do not perform argument-dependent lookup if normal
11074 lookup finds a non-function, in accordance with the
11075 expected resolution of DR 218. */
11077 && ((is_overloaded_fn (function
)
11078 /* If lookup found a member function, the Koenig lookup is
11079 not appropriate, even if an unqualified-name was used
11080 to denote the function. */
11081 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
11082 || TREE_CODE (function
) == IDENTIFIER_NODE
))
11083 function
= perform_koenig_lookup (function
, call_args
);
11085 if (TREE_CODE (function
) == IDENTIFIER_NODE
)
11087 unqualified_name_lookup_error (function
);
11088 return error_mark_node
;
11091 /* Remember that there was a reference to this entity. */
11092 if (DECL_P (function
))
11093 mark_used (function
);
11095 if (TREE_CODE (function
) == OFFSET_REF
)
11096 return build_offset_ref_call_from_tree (function
, call_args
);
11097 if (TREE_CODE (function
) == COMPONENT_REF
)
11099 if (!BASELINK_P (TREE_OPERAND (function
, 1)))
11100 return finish_call_expr (function
, call_args
,
11101 /*disallow_virtual=*/false,
11102 /*koenig_p=*/false,
11105 return (build_new_method_call
11106 (TREE_OPERAND (function
, 0),
11107 TREE_OPERAND (function
, 1),
11108 call_args
, NULL_TREE
,
11109 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
11113 return finish_call_expr (function
, call_args
,
11114 /*disallow_virtual=*/qualified_p
,
11120 return build_x_conditional_expr
11121 (RECUR (TREE_OPERAND (t
, 0)),
11122 RECUR (TREE_OPERAND (t
, 1)),
11123 RECUR (TREE_OPERAND (t
, 2)),
11126 case PSEUDO_DTOR_EXPR
:
11127 return finish_pseudo_destructor_expr
11128 (RECUR (TREE_OPERAND (t
, 0)),
11129 RECUR (TREE_OPERAND (t
, 1)),
11130 RECUR (TREE_OPERAND (t
, 2)));
11134 tree purpose
, value
, chain
;
11136 if (t
== void_list_node
)
11139 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
11140 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
11142 /* We have pack expansions, so expand those and
11143 create a new list out of it. */
11144 tree purposevec
= NULL_TREE
;
11145 tree valuevec
= NULL_TREE
;
11149 /* Expand the argument expressions. */
11150 if (TREE_PURPOSE (t
))
11151 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
11152 complain
, in_decl
);
11153 if (TREE_VALUE (t
))
11154 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
11155 complain
, in_decl
);
11157 /* Build the rest of the list. */
11158 chain
= TREE_CHAIN (t
);
11159 if (chain
&& chain
!= void_type_node
)
11160 chain
= RECUR (chain
);
11162 /* Determine the number of arguments. */
11163 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
11165 len
= TREE_VEC_LENGTH (purposevec
);
11166 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
11168 else if (TREE_CODE (valuevec
) == TREE_VEC
)
11169 len
= TREE_VEC_LENGTH (valuevec
);
11172 /* Since we only performed a partial substitution into
11173 the argument pack, we only return a single list
11175 if (purposevec
== TREE_PURPOSE (t
)
11176 && valuevec
== TREE_VALUE (t
)
11177 && chain
== TREE_CHAIN (t
))
11180 return tree_cons (purposevec
, valuevec
, chain
);
11183 /* Convert the argument vectors into a TREE_LIST */
11187 /* Grab the Ith values. */
11189 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
11192 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
11195 /* Build the list (backwards). */
11196 chain
= tree_cons (purpose
, value
, chain
);
11202 purpose
= TREE_PURPOSE (t
);
11204 purpose
= RECUR (purpose
);
11205 value
= TREE_VALUE (t
);
11207 value
= RECUR (value
);
11208 chain
= TREE_CHAIN (t
);
11209 if (chain
&& chain
!= void_type_node
)
11210 chain
= RECUR (chain
);
11211 if (purpose
== TREE_PURPOSE (t
)
11212 && value
== TREE_VALUE (t
)
11213 && chain
== TREE_CHAIN (t
))
11215 return tree_cons (purpose
, value
, chain
);
11218 case COMPONENT_REF
:
11224 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
11225 args
, complain
, in_decl
);
11226 /* Remember that there was a reference to this entity. */
11227 if (DECL_P (object
))
11228 mark_used (object
);
11229 object_type
= TREE_TYPE (object
);
11231 member
= TREE_OPERAND (t
, 1);
11232 if (BASELINK_P (member
))
11233 member
= tsubst_baselink (member
,
11234 non_reference (TREE_TYPE (object
)),
11235 args
, complain
, in_decl
);
11237 member
= tsubst_copy (member
, args
, complain
, in_decl
);
11238 if (member
== error_mark_node
)
11239 return error_mark_node
;
11241 if (object_type
&& !CLASS_TYPE_P (object_type
))
11243 if (SCALAR_TYPE_P (object_type
))
11245 tree s
= NULL_TREE
;
11246 tree dtor
= member
;
11248 if (TREE_CODE (dtor
) == SCOPE_REF
)
11250 s
= TREE_OPERAND (dtor
, 0);
11251 dtor
= TREE_OPERAND (dtor
, 1);
11253 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
11255 dtor
= TREE_OPERAND (dtor
, 0);
11257 return finish_pseudo_destructor_expr (object
, s
, dtor
);
11261 else if (TREE_CODE (member
) == SCOPE_REF
11262 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
11267 /* Lookup the template functions now that we know what the
11269 tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
11270 args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
11271 member
= lookup_qualified_name (TREE_OPERAND (member
, 0), tmpl
,
11272 /*is_type_p=*/false,
11273 /*complain=*/false);
11274 if (BASELINK_P (member
))
11276 BASELINK_FUNCTIONS (member
)
11277 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
11279 member
= (adjust_result_of_qualified_name_lookup
11280 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
11285 qualified_name_lookup_error (object_type
, tmpl
, member
);
11286 return error_mark_node
;
11289 else if (TREE_CODE (member
) == SCOPE_REF
11290 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
11291 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
11293 if (complain
& tf_error
)
11295 if (TYPE_P (TREE_OPERAND (member
, 0)))
11296 error ("%qT is not a class or namespace",
11297 TREE_OPERAND (member
, 0));
11299 error ("%qD is not a class or namespace",
11300 TREE_OPERAND (member
, 0));
11302 return error_mark_node
;
11304 else if (TREE_CODE (member
) == FIELD_DECL
)
11305 return finish_non_static_data_member (member
, object
, NULL_TREE
);
11307 return finish_class_member_access_expr (object
, member
,
11308 /*template_p=*/false,
11314 (RECUR (TREE_OPERAND (t
, 0)));
11318 VEC(constructor_elt
,gc
) *n
;
11319 constructor_elt
*ce
;
11320 unsigned HOST_WIDE_INT idx
;
11321 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
11322 bool process_index_p
;
11324 bool need_copy_p
= false;
11326 if (type
== error_mark_node
)
11327 return error_mark_node
;
11329 /* digest_init will do the wrong thing if we let it. */
11330 if (type
&& TYPE_PTRMEMFUNC_P (type
))
11333 /* We do not want to process the index of aggregate
11334 initializers as they are identifier nodes which will be
11335 looked up by digest_init. */
11336 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
11338 n
= VEC_copy (constructor_elt
, gc
, CONSTRUCTOR_ELTS (t
));
11339 newlen
= VEC_length (constructor_elt
, n
);
11340 for (idx
= 0; VEC_iterate (constructor_elt
, n
, idx
, ce
); idx
++)
11342 if (ce
->index
&& process_index_p
)
11343 ce
->index
= RECUR (ce
->index
);
11345 if (PACK_EXPANSION_P (ce
->value
))
11347 /* Substitute into the pack expansion. */
11348 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
11351 if (ce
->value
== error_mark_node
)
11353 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
11354 /* Just move the argument into place. */
11355 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
11358 /* Update the length of the final CONSTRUCTOR
11359 arguments vector, and note that we will need to
11361 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
11362 need_copy_p
= true;
11366 ce
->value
= RECUR (ce
->value
);
11371 VEC(constructor_elt
,gc
) *old_n
= n
;
11373 n
= VEC_alloc (constructor_elt
, gc
, newlen
);
11374 for (idx
= 0; VEC_iterate (constructor_elt
, old_n
, idx
, ce
);
11377 if (TREE_CODE (ce
->value
) == TREE_VEC
)
11379 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
11380 for (i
= 0; i
< len
; ++i
)
11381 CONSTRUCTOR_APPEND_ELT (n
, 0,
11382 TREE_VEC_ELT (ce
->value
, i
));
11385 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
11389 if (TREE_HAS_CONSTRUCTOR (t
))
11390 return finish_compound_literal (type
, n
);
11392 return build_constructor (NULL_TREE
, n
);
11397 tree operand_0
= RECUR (TREE_OPERAND (t
, 0));
11398 if (TYPE_P (operand_0
))
11399 return get_typeid (operand_0
);
11400 return build_typeid (operand_0
);
11410 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
11412 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
11413 /* If the original type was a reference, we'll be wrapped in
11414 the appropriate INDIRECT_REF. */
11415 r
= convert_from_reference (r
);
11420 return build_x_va_arg (RECUR (TREE_OPERAND (t
, 0)),
11421 tsubst_copy (TREE_TYPE (t
), args
, complain
,
11424 case OFFSETOF_EXPR
:
11425 return finish_offsetof (RECUR (TREE_OPERAND (t
, 0)));
11429 tree type1
= tsubst_copy (TRAIT_EXPR_TYPE1 (t
), args
,
11430 complain
, in_decl
);
11432 tree type2
= TRAIT_EXPR_TYPE2 (t
);
11434 type2
= tsubst_copy (type2
, args
, complain
, in_decl
);
11436 return finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
);
11441 tree old_stmt_expr
= cur_stmt_expr
;
11442 tree stmt_expr
= begin_stmt_expr ();
11444 cur_stmt_expr
= stmt_expr
;
11445 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
11446 integral_constant_expression_p
);
11447 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
11448 cur_stmt_expr
= old_stmt_expr
;
11454 t
= tsubst_copy (t
, args
, complain
, in_decl
);
11455 /* As in finish_id_expression, we resolve enumeration constants
11456 to their underlying values. */
11457 if (TREE_CODE (t
) == CONST_DECL
)
11459 used_types_insert (TREE_TYPE (t
));
11460 return DECL_INITIAL (t
);
11465 /* Handle Objective-C++ constructs, if appropriate. */
11468 = objcp_tsubst_copy_and_build (t
, args
, complain
,
11469 in_decl
, /*function_p=*/false);
11473 return tsubst_copy (t
, args
, complain
, in_decl
);
11479 /* Verify that the instantiated ARGS are valid. For type arguments,
11480 make sure that the type's linkage is ok. For non-type arguments,
11481 make sure they are constants if they are integral or enumerations.
11482 Emit an error under control of COMPLAIN, and return TRUE on error. */
11485 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
11487 int ix
, len
= DECL_NTPARMS (tmpl
);
11488 bool result
= false;
11490 for (ix
= 0; ix
!= len
; ix
++)
11492 tree t
= TREE_VEC_ELT (args
, ix
);
11496 /* [basic.link]: A name with no linkage (notably, the name
11497 of a class or enumeration declared in a local scope)
11498 shall not be used to declare an entity with linkage.
11499 This implies that names with no linkage cannot be used as
11500 template arguments. */
11501 tree nt
= no_linkage_check (t
, /*relaxed_p=*/false);
11505 /* DR 488 makes use of a type with no linkage cause
11506 type deduction to fail. */
11507 if (complain
& tf_error
)
11509 if (TYPE_ANONYMOUS_P (nt
))
11510 error ("%qT is/uses anonymous type", t
);
11512 error ("template argument for %qD uses local type %qT",
11517 /* In order to avoid all sorts of complications, we do not
11518 allow variably-modified types as template arguments. */
11519 else if (variably_modified_type_p (t
, NULL_TREE
))
11521 if (complain
& tf_error
)
11522 error ("%qT is a variably modified type", t
);
11526 /* A non-type argument of integral or enumerated type must be a
11528 else if (TREE_TYPE (t
)
11529 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
11530 && !TREE_CONSTANT (t
))
11532 if (complain
& tf_error
)
11533 error ("integral expression %qE is not constant", t
);
11537 if (result
&& (complain
& tf_error
))
11538 error (" trying to instantiate %qD", tmpl
);
11542 /* Instantiate the indicated variable or function template TMPL with
11543 the template arguments in TARG_PTR. */
11546 instantiate_template (tree tmpl
, tree targ_ptr
, tsubst_flags_t complain
)
11551 HOST_WIDE_INT saved_processing_template_decl
;
11553 if (tmpl
== error_mark_node
)
11554 return error_mark_node
;
11556 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
11558 /* If this function is a clone, handle it specially. */
11559 if (DECL_CLONED_FUNCTION_P (tmpl
))
11564 spec
= instantiate_template (DECL_CLONED_FUNCTION (tmpl
), targ_ptr
,
11566 if (spec
== error_mark_node
)
11567 return error_mark_node
;
11569 /* Look for the clone. */
11570 FOR_EACH_CLONE (clone
, spec
)
11571 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
11573 /* We should always have found the clone by now. */
11574 gcc_unreachable ();
11578 /* Check to see if we already have this specialization. */
11579 spec
= retrieve_specialization (tmpl
, targ_ptr
,
11580 /*class_specializations_p=*/false);
11581 if (spec
!= NULL_TREE
)
11584 gen_tmpl
= most_general_template (tmpl
);
11585 if (tmpl
!= gen_tmpl
)
11587 /* The TMPL is a partial instantiation. To get a full set of
11588 arguments we must add the arguments used to perform the
11589 partial instantiation. */
11590 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
11593 /* Check to see if we already have this specialization. */
11594 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
,
11595 /*class_specializations_p=*/false);
11596 if (spec
!= NULL_TREE
)
11600 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
11602 return error_mark_node
;
11604 /* We are building a FUNCTION_DECL, during which the access of its
11605 parameters and return types have to be checked. However this
11606 FUNCTION_DECL which is the desired context for access checking
11607 is not built yet. We solve this chicken-and-egg problem by
11608 deferring all checks until we have the FUNCTION_DECL. */
11609 push_deferring_access_checks (dk_deferred
);
11611 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11612 (because, for example, we have encountered a non-dependent
11613 function call in the body of a template function and must now
11614 determine which of several overloaded functions will be called),
11615 within the instantiation itself we are not processing a
11617 saved_processing_template_decl
= processing_template_decl
;
11618 processing_template_decl
= 0;
11619 /* Substitute template parameters to obtain the specialization. */
11620 fndecl
= tsubst (DECL_TEMPLATE_RESULT (gen_tmpl
),
11621 targ_ptr
, complain
, gen_tmpl
);
11622 processing_template_decl
= saved_processing_template_decl
;
11623 if (fndecl
== error_mark_node
)
11624 return error_mark_node
;
11626 /* Now we know the specialization, compute access previously
11628 push_access_scope (fndecl
);
11629 perform_deferred_access_checks ();
11630 pop_access_scope (fndecl
);
11631 pop_deferring_access_checks ();
11633 /* The DECL_TI_TEMPLATE should always be the immediate parent
11634 template, not the most general template. */
11635 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
11637 /* If we've just instantiated the main entry point for a function,
11638 instantiate all the alternate entry points as well. We do this
11639 by cloning the instantiation of the main entry point, not by
11640 instantiating the template clones. */
11641 if (TREE_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl
)))
11642 clone_function_decl (fndecl
, /*update_method_vec_p=*/0);
11647 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11648 arguments that are being used when calling it. TARGS is a vector
11649 into which the deduced template arguments are placed.
11651 Return zero for success, 2 for an incomplete match that doesn't resolve
11652 all the types, and 1 for complete failure. An error message will be
11653 printed only for an incomplete match.
11655 If FN is a conversion operator, or we are trying to produce a specific
11656 specialization, RETURN_TYPE is the return type desired.
11658 The EXPLICIT_TARGS are explicit template arguments provided via a
11661 The parameter STRICT is one of:
11664 We are deducing arguments for a function call, as in
11665 [temp.deduct.call].
11668 We are deducing arguments for a conversion function, as in
11669 [temp.deduct.conv].
11672 We are deducing arguments when doing an explicit instantiation
11673 as in [temp.explicit], when determining an explicit specialization
11674 as in [temp.expl.spec], or when taking the address of a function
11675 template, as in [temp.deduct.funcaddr]. */
11678 fn_type_unification (tree fn
,
11679 tree explicit_targs
,
11683 unification_kind_t strict
,
11689 bool incomplete_argument_packs_p
= false;
11691 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
11693 fntype
= TREE_TYPE (fn
);
11694 if (explicit_targs
)
11698 The specified template arguments must match the template
11699 parameters in kind (i.e., type, nontype, template), and there
11700 must not be more arguments than there are parameters;
11701 otherwise type deduction fails.
11703 Nontype arguments must match the types of the corresponding
11704 nontype template parameters, or must be convertible to the
11705 types of the corresponding nontype parameters as specified in
11706 _temp.arg.nontype_, otherwise type deduction fails.
11708 All references in the function type of the function template
11709 to the corresponding template parameters are replaced by the
11710 specified template argument values. If a substitution in a
11711 template parameter or in the function type of the function
11712 template results in an invalid type, type deduction fails. */
11713 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
11714 int i
, len
= TREE_VEC_LENGTH (tparms
);
11715 tree converted_args
;
11716 bool incomplete
= false;
11718 if (explicit_targs
== error_mark_node
)
11722 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
, tf_none
,
11723 /*require_all_args=*/false,
11724 /*use_default_args=*/false));
11725 if (converted_args
== error_mark_node
)
11728 /* Substitute the explicit args into the function type. This is
11729 necessary so that, for instance, explicitly declared function
11730 arguments can match null pointed constants. If we were given
11731 an incomplete set of explicit args, we must not do semantic
11732 processing during substitution as we could create partial
11734 for (i
= 0; i
< len
; i
++)
11736 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
11737 bool parameter_pack
= false;
11739 /* Dig out the actual parm. */
11740 if (TREE_CODE (parm
) == TYPE_DECL
11741 || TREE_CODE (parm
) == TEMPLATE_DECL
)
11743 parm
= TREE_TYPE (parm
);
11744 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
11746 else if (TREE_CODE (parm
) == PARM_DECL
)
11748 parm
= DECL_INITIAL (parm
);
11749 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
11752 if (parameter_pack
)
11756 template_parm_level_and_index (parm
, &level
, &idx
);
11758 /* Mark the argument pack as "incomplete". We could
11759 still deduce more arguments during unification. */
11760 targ
= TMPL_ARG (converted_args
, level
, idx
);
11763 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
11764 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
11765 = ARGUMENT_PACK_ARGS (targ
);
11768 /* We have some incomplete argument packs. */
11769 incomplete_argument_packs_p
= true;
11773 if (incomplete_argument_packs_p
)
11774 /* Any substitution is guaranteed to be incomplete if there
11775 are incomplete argument packs, because we can still deduce
11779 incomplete
= NUM_TMPL_ARGS (explicit_targs
) != NUM_TMPL_ARGS (targs
);
11781 processing_template_decl
+= incomplete
;
11782 fntype
= tsubst (fntype
, converted_args
, tf_none
, NULL_TREE
);
11783 processing_template_decl
-= incomplete
;
11785 if (fntype
== error_mark_node
)
11788 /* Place the explicitly specified arguments in TARGS. */
11789 for (i
= NUM_TMPL_ARGS (converted_args
); i
--;)
11790 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (converted_args
, i
);
11793 /* Never do unification on the 'this' parameter. */
11794 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
11798 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
11799 args
= tree_cons (NULL_TREE
, return_type
, args
);
11802 /* We allow incomplete unification without an error message here
11803 because the standard doesn't seem to explicitly prohibit it. Our
11804 callers must be ready to deal with unification failures in any
11806 result
= type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
11807 targs
, parms
, args
, /*subr=*/0,
11810 if (result
== 0 && incomplete_argument_packs_p
)
11812 int i
, len
= NUM_TMPL_ARGS (targs
);
11814 /* Clear the "incomplete" flags on all argument packs. */
11815 for (i
= 0; i
< len
; i
++)
11817 tree arg
= TREE_VEC_ELT (targs
, i
);
11818 if (ARGUMENT_PACK_P (arg
))
11820 ARGUMENT_PACK_INCOMPLETE_P (arg
) = 0;
11821 ARGUMENT_PACK_EXPLICIT_ARGS (arg
) = NULL_TREE
;
11826 /* Now that we have bindings for all of the template arguments,
11827 ensure that the arguments deduced for the template template
11828 parameters have compatible template parameter lists. We cannot
11829 check this property before we have deduced all template
11830 arguments, because the template parameter types of a template
11831 template parameter might depend on prior template parameters
11832 deduced after the template template parameter. The following
11833 ill-formed example illustrates this issue:
11835 template<typename T, template<T> class C> void f(C<5>, T);
11837 template<int N> struct X {};
11840 f(X<5>(), 5l); // error: template argument deduction fails
11843 The template parameter list of 'C' depends on the template type
11844 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
11845 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
11846 time that we deduce 'C'. */
11848 && !template_template_parm_bindings_ok_p
11849 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
11853 /* All is well so far. Now, check:
11857 When all template arguments have been deduced, all uses of
11858 template parameters in nondeduced contexts are replaced with
11859 the corresponding deduced argument values. If the
11860 substitution results in an invalid type, as described above,
11861 type deduction fails. */
11862 if (tsubst (TREE_TYPE (fn
), targs
, tf_none
, NULL_TREE
)
11863 == error_mark_node
)
11869 /* Adjust types before performing type deduction, as described in
11870 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11871 sections are symmetric. PARM is the type of a function parameter
11872 or the return type of the conversion function. ARG is the type of
11873 the argument passed to the call, or the type of the value
11874 initialized with the result of the conversion function.
11875 ARG_EXPR is the original argument expression, which may be null. */
11878 maybe_adjust_types_for_deduction (unification_kind_t strict
,
11892 /* Swap PARM and ARG throughout the remainder of this
11893 function; the handling is precisely symmetric since PARM
11894 will initialize ARG rather than vice versa. */
11902 /* There is nothing to do in this case. */
11906 gcc_unreachable ();
11909 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
11911 /* [temp.deduct.call]
11913 If P is not a reference type:
11915 --If A is an array type, the pointer type produced by the
11916 array-to-pointer standard conversion (_conv.array_) is
11917 used in place of A for type deduction; otherwise,
11919 --If A is a function type, the pointer type produced by
11920 the function-to-pointer standard conversion
11921 (_conv.func_) is used in place of A for type deduction;
11924 --If A is a cv-qualified type, the top level
11925 cv-qualifiers of A's type are ignored for type
11927 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
11928 *arg
= build_pointer_type (TREE_TYPE (*arg
));
11929 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
11930 *arg
= build_pointer_type (*arg
);
11932 *arg
= TYPE_MAIN_VARIANT (*arg
);
11935 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11936 of the form T&&, where T is a template parameter, and the argument
11937 is an lvalue, T is deduced as A& */
11938 if (TREE_CODE (*parm
) == REFERENCE_TYPE
11939 && TYPE_REF_IS_RVALUE (*parm
)
11940 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
11941 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
11942 && arg_expr
&& real_lvalue_p (arg_expr
))
11943 *arg
= build_reference_type (*arg
);
11945 /* [temp.deduct.call]
11947 If P is a cv-qualified type, the top level cv-qualifiers
11948 of P's type are ignored for type deduction. If P is a
11949 reference type, the type referred to by P is used for
11951 *parm
= TYPE_MAIN_VARIANT (*parm
);
11952 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
11954 *parm
= TREE_TYPE (*parm
);
11955 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
11958 /* DR 322. For conversion deduction, remove a reference type on parm
11959 too (which has been swapped into ARG). */
11960 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
11961 *arg
= TREE_TYPE (*arg
);
11966 /* Most parms like fn_type_unification.
11968 If SUBR is 1, we're being called recursively (to unify the
11969 arguments of a function or method parameter of a function
11973 type_unification_real (tree tparms
,
11978 unification_kind_t strict
,
11981 tree parm
, arg
, arg_expr
;
11983 int ntparms
= TREE_VEC_LENGTH (tparms
);
11985 int saw_undeduced
= 0;
11988 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
11989 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
11990 gcc_assert (!xargs
|| TREE_CODE (xargs
) == TREE_LIST
);
11991 gcc_assert (ntparms
> 0);
11996 sub_strict
= (UNIFY_ALLOW_OUTER_LEVEL
| UNIFY_ALLOW_MORE_CV_QUAL
11997 | UNIFY_ALLOW_DERIVED
);
12001 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
12005 sub_strict
= UNIFY_ALLOW_NONE
;
12009 gcc_unreachable ();
12016 while (parms
&& parms
!= void_list_node
12017 && args
&& args
!= void_list_node
)
12019 if (TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
12022 parm
= TREE_VALUE (parms
);
12023 parms
= TREE_CHAIN (parms
);
12024 arg
= TREE_VALUE (args
);
12025 args
= TREE_CHAIN (args
);
12028 if (arg
== error_mark_node
)
12030 if (arg
== unknown_type_node
)
12031 /* We can't deduce anything from this, but we might get all the
12032 template args from other function args. */
12035 /* Conversions will be performed on a function argument that
12036 corresponds with a function parameter that contains only
12037 non-deducible template parameters and explicitly specified
12038 template parameters. */
12039 if (!uses_template_parms (parm
))
12044 type
= TREE_TYPE (arg
);
12048 if (same_type_p (parm
, type
))
12050 if (strict
!= DEDUCE_EXACT
12051 && can_convert_arg (parm
, type
, TYPE_P (arg
) ? NULL_TREE
: arg
,
12060 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
12061 if (type_unknown_p (arg
))
12063 /* [temp.deduct.type]
12065 A template-argument can be deduced from a pointer to
12066 function or pointer to member function argument if
12067 the set of overloaded functions does not contain
12068 function templates and at most one of a set of
12069 overloaded functions provides a unique match. */
12070 if (resolve_overloaded_unification
12071 (tparms
, targs
, parm
, arg
, strict
, sub_strict
))
12077 arg
= unlowered_expr_type (arg
);
12078 if (arg
== error_mark_node
)
12083 int arg_strict
= sub_strict
;
12086 arg_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
,
12089 if (unify (tparms
, targs
, parm
, arg
, arg_strict
))
12096 && parms
!= void_list_node
12097 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
12099 /* Unify the remaining arguments with the pack expansion type. */
12101 tree parmvec
= make_tree_vec (1);
12105 /* Count the number of arguments that remain. */
12106 for (t
= args
; t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
12109 /* Allocate a TREE_VEC and copy in all of the arguments */
12110 argvec
= make_tree_vec (len
);
12111 for (i
= 0; args
&& args
!= void_list_node
; args
= TREE_CHAIN (args
))
12113 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (args
);
12117 /* Copy the parameter into parmvec. */
12118 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
12119 if (unify_pack_expansion (tparms
, targs
, parmvec
, argvec
, strict
,
12120 /*call_args_p=*/true, /*subr=*/subr
))
12123 /* Advance to the end of the list of parameters. */
12124 parms
= TREE_CHAIN (parms
);
12127 /* Fail if we've reached the end of the parm list, and more args
12128 are present, and the parm list isn't variadic. */
12129 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
12131 /* Fail if parms are left and they don't have default values. */
12132 if (parms
&& parms
!= void_list_node
12133 && TREE_PURPOSE (parms
) == NULL_TREE
)
12137 for (i
= 0; i
< ntparms
; i
++)
12138 if (!TREE_VEC_ELT (targs
, i
))
12142 if (TREE_VEC_ELT (tparms
, i
) == error_mark_node
)
12145 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
12147 /* If this is an undeduced nontype parameter that depends on
12148 a type parameter, try another pass; its type may have been
12149 deduced from a later argument than the one from which
12150 this parameter can be deduced. */
12151 if (TREE_CODE (tparm
) == PARM_DECL
12152 && uses_template_parms (TREE_TYPE (tparm
))
12153 && !saw_undeduced
++)
12156 /* Core issue #226 (C++0x) [temp.deduct]:
12158 If a template argument has not been deduced, its
12159 default template argument, if any, is used.
12161 When we are in C++98 mode, TREE_PURPOSE will either
12162 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12163 to explicitly check cxx_dialect here. */
12164 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
12166 tree arg
= tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)),
12167 targs
, tf_none
, NULL_TREE
);
12168 if (arg
== error_mark_node
)
12172 TREE_VEC_ELT (targs
, i
) = arg
;
12177 /* If the type parameter is a parameter pack, then it will
12178 be deduced to an empty parameter pack. */
12179 if (template_parameter_pack_p (tparm
))
12183 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
12185 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
12186 TREE_TYPE (arg
) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm
));
12187 TREE_CONSTANT (arg
) = 1;
12190 arg
= make_node (TYPE_ARGUMENT_PACK
);
12192 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
12194 TREE_VEC_ELT (targs
, i
) = arg
;
12204 /* Subroutine of type_unification_real. Args are like the variables
12205 at the call site. ARG is an overloaded function (or template-id);
12206 we try deducing template args from each of the overloads, and if
12207 only one succeeds, we go with that. Modifies TARGS and returns
12208 true on success. */
12211 resolve_overloaded_unification (tree tparms
,
12215 unification_kind_t strict
,
12218 tree tempargs
= copy_node (targs
);
12222 if (TREE_CODE (arg
) == ADDR_EXPR
)
12224 arg
= TREE_OPERAND (arg
, 0);
12230 if (TREE_CODE (arg
) == COMPONENT_REF
)
12231 /* Handle `&x' where `x' is some static or non-static member
12233 arg
= TREE_OPERAND (arg
, 1);
12235 if (TREE_CODE (arg
) == OFFSET_REF
)
12236 arg
= TREE_OPERAND (arg
, 1);
12238 /* Strip baselink information. */
12239 if (BASELINK_P (arg
))
12240 arg
= BASELINK_FUNCTIONS (arg
);
12242 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
12244 /* If we got some explicit template args, we need to plug them into
12245 the affected templates before we try to unify, in case the
12246 explicit args will completely resolve the templates in question. */
12248 tree expl_subargs
= TREE_OPERAND (arg
, 1);
12249 arg
= TREE_OPERAND (arg
, 0);
12251 for (; arg
; arg
= OVL_NEXT (arg
))
12253 tree fn
= OVL_CURRENT (arg
);
12254 tree subargs
, elem
;
12256 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
12259 ++processing_template_decl
;
12260 subargs
= get_bindings (fn
, DECL_TEMPLATE_RESULT (fn
),
12261 expl_subargs
, /*check_ret=*/false);
12264 elem
= tsubst (TREE_TYPE (fn
), subargs
, tf_none
, NULL_TREE
);
12265 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
12266 elem
, strict
, sub_strict
, addr_p
);
12268 --processing_template_decl
;
12271 else if (TREE_CODE (arg
) != OVERLOAD
12272 && TREE_CODE (arg
) != FUNCTION_DECL
)
12273 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12274 -- but the deduction does not succeed because the expression is
12275 not just the function on its own. */
12278 for (; arg
; arg
= OVL_NEXT (arg
))
12279 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
12280 TREE_TYPE (OVL_CURRENT (arg
)),
12281 strict
, sub_strict
, addr_p
);
12283 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12284 to function or pointer to member function argument if the set of
12285 overloaded functions does not contain function templates and at most
12286 one of a set of overloaded functions provides a unique match.
12288 So if we found multiple possibilities, we return success but don't
12289 deduce anything. */
12293 int i
= TREE_VEC_LENGTH (targs
);
12295 if (TREE_VEC_ELT (tempargs
, i
))
12296 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
12304 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12305 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12306 different overloads deduce different arguments for a given parm.
12307 ADDR_P is true if the expression for which deduction is being
12308 performed was of the form "& fn" rather than simply "fn".
12310 Returns 1 on success. */
12313 try_one_overload (tree tparms
,
12318 unification_kind_t strict
,
12326 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12327 to function or pointer to member function argument if the set of
12328 overloaded functions does not contain function templates and at most
12329 one of a set of overloaded functions provides a unique match.
12331 So if this is a template, just return success. */
12333 if (uses_template_parms (arg
))
12336 if (TREE_CODE (arg
) == METHOD_TYPE
)
12337 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
12339 arg
= build_pointer_type (arg
);
12341 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
12343 /* We don't copy orig_targs for this because if we have already deduced
12344 some template args from previous args, unify would complain when we
12345 try to deduce a template parameter for the same argument, even though
12346 there isn't really a conflict. */
12347 nargs
= TREE_VEC_LENGTH (targs
);
12348 tempargs
= make_tree_vec (nargs
);
12350 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
) != 0)
12353 /* First make sure we didn't deduce anything that conflicts with
12354 explicitly specified args. */
12355 for (i
= nargs
; i
--; )
12357 tree elt
= TREE_VEC_ELT (tempargs
, i
);
12358 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
12362 else if (uses_template_parms (elt
))
12363 /* Since we're unifying against ourselves, we will fill in
12364 template args used in the function parm list with our own
12365 template parms. Discard them. */
12366 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
12367 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
12371 for (i
= nargs
; i
--; )
12373 tree elt
= TREE_VEC_ELT (tempargs
, i
);
12376 TREE_VEC_ELT (targs
, i
) = elt
;
12382 /* PARM is a template class (perhaps with unbound template
12383 parameters). ARG is a fully instantiated type. If ARG can be
12384 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12385 TARGS are as for unify. */
12388 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
)
12390 tree copy_of_targs
;
12392 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
12393 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
12394 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
))))
12397 /* We need to make a new template argument vector for the call to
12398 unify. If we used TARGS, we'd clutter it up with the result of
12399 the attempted unification, even if this class didn't work out.
12400 We also don't want to commit ourselves to all the unifications
12401 we've already done, since unification is supposed to be done on
12402 an argument-by-argument basis. In other words, consider the
12403 following pathological case:
12405 template <int I, int J, int K>
12408 template <int I, int J>
12409 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12411 template <int I, int J, int K>
12412 void f(S<I, J, K>, S<I, I, I>);
12421 Now, by the time we consider the unification involving `s2', we
12422 already know that we must have `f<0, 0, 0>'. But, even though
12423 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12424 because there are two ways to unify base classes of S<0, 1, 2>
12425 with S<I, I, I>. If we kept the already deduced knowledge, we
12426 would reject the possibility I=1. */
12427 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
12429 /* If unification failed, we're done. */
12430 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
12431 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
))
12437 /* Given a template type PARM and a class type ARG, find the unique
12438 base type in ARG that is an instance of PARM. We do not examine
12439 ARG itself; only its base-classes. If there is not exactly one
12440 appropriate base class, return NULL_TREE. PARM may be the type of
12441 a partial specialization, as well as a plain template type. Used
12445 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
)
12447 tree rval
= NULL_TREE
;
12450 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
12452 binfo
= TYPE_BINFO (complete_type (arg
));
12454 /* The type could not be completed. */
12457 /* Walk in inheritance graph order. The search order is not
12458 important, and this avoids multiple walks of virtual bases. */
12459 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
12461 tree r
= try_class_unification (tparms
, targs
, parm
, BINFO_TYPE (binfo
));
12465 /* If there is more than one satisfactory baseclass, then:
12469 If they yield more than one possible deduced A, the type
12473 if (rval
&& !same_type_p (r
, rval
))
12483 /* Returns the level of DECL, which declares a template parameter. */
12486 template_decl_level (tree decl
)
12488 switch (TREE_CODE (decl
))
12491 case TEMPLATE_DECL
:
12492 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
12495 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
12498 gcc_unreachable ();
12503 /* Decide whether ARG can be unified with PARM, considering only the
12504 cv-qualifiers of each type, given STRICT as documented for unify.
12505 Returns nonzero iff the unification is OK on that basis. */
12508 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
12510 int arg_quals
= cp_type_quals (arg
);
12511 int parm_quals
= cp_type_quals (parm
);
12513 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
12514 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
12516 /* Although a CVR qualifier is ignored when being applied to a
12517 substituted template parameter ([8.3.2]/1 for example), that
12518 does not apply during deduction [14.8.2.4]/1, (even though
12519 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12520 this). Except when we're allowing additional CV qualifiers
12521 at the outer level [14.8.2.1]/3,1st bullet. */
12522 if ((TREE_CODE (arg
) == REFERENCE_TYPE
12523 || TREE_CODE (arg
) == FUNCTION_TYPE
12524 || TREE_CODE (arg
) == METHOD_TYPE
)
12525 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
12528 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
12529 && (parm_quals
& TYPE_QUAL_RESTRICT
))
12533 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
12534 && (arg_quals
& parm_quals
) != parm_quals
)
12537 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
12538 && (parm_quals
& arg_quals
) != arg_quals
)
12544 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12546 template_parm_level_and_index (tree parm
, int* level
, int* index
)
12548 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
12549 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
12550 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12552 *index
= TEMPLATE_TYPE_IDX (parm
);
12553 *level
= TEMPLATE_TYPE_LEVEL (parm
);
12557 *index
= TEMPLATE_PARM_IDX (parm
);
12558 *level
= TEMPLATE_PARM_LEVEL (parm
);
12562 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12563 expansion at the end of PACKED_PARMS. Returns 0 if the type
12564 deduction succeeds, 1 otherwise. STRICT is the same as in
12565 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12566 call argument list. We'll need to adjust the arguments to make them
12567 types. SUBR tells us if this is from a recursive call to
12568 type_unification_real. */
12570 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
12571 tree packed_args
, int strict
, bool call_args_p
,
12575 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
12576 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
12577 tree pack
, packs
= NULL_TREE
;
12578 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
12579 int len
= TREE_VEC_LENGTH (packed_args
);
12581 /* Determine the parameter packs we will be deducing from the
12582 pattern, and record their current deductions. */
12583 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
12584 pack
; pack
= TREE_CHAIN (pack
))
12586 tree parm_pack
= TREE_VALUE (pack
);
12589 /* Determine the index and level of this parameter pack. */
12590 template_parm_level_and_index (parm_pack
, &level
, &idx
);
12592 /* Keep track of the parameter packs and their corresponding
12594 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
12595 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
12598 /* Loop through all of the arguments that have not yet been
12599 unified and unify each with the pattern. */
12600 for (i
= start
; i
< len
; i
++)
12602 tree parm
= pattern
;
12604 /* For each parameter pack, clear out the deduced value so that
12605 we can deduce it again. */
12606 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12609 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12611 TMPL_ARG (targs
, level
, idx
) = NULL_TREE
;
12614 /* Unify the pattern with the current argument. */
12616 tree arg
= TREE_VEC_ELT (packed_args
, i
);
12617 tree arg_expr
= NULL_TREE
;
12618 int arg_strict
= strict
;
12619 bool skip_arg_p
= false;
12625 /* This mirrors what we do in type_unification_real. */
12629 sub_strict
= (UNIFY_ALLOW_OUTER_LEVEL
12630 | UNIFY_ALLOW_MORE_CV_QUAL
12631 | UNIFY_ALLOW_DERIVED
);
12635 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
12639 sub_strict
= UNIFY_ALLOW_NONE
;
12643 gcc_unreachable ();
12648 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
12649 if (type_unknown_p (arg
))
12651 /* [temp.deduct.type] A template-argument can be
12652 deduced from a pointer to function or pointer
12653 to member function argument if the set of
12654 overloaded functions does not contain function
12655 templates and at most one of a set of
12656 overloaded functions provides a unique
12659 if (resolve_overloaded_unification
12660 (tparms
, targs
, parm
, arg
, strict
, sub_strict
)
12669 arg
= unlowered_expr_type (arg
);
12670 if (arg
== error_mark_node
)
12675 arg_strict
= sub_strict
;
12679 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
,
12685 if (unify (tparms
, targs
, parm
, arg
, arg_strict
))
12690 /* For each parameter pack, collect the deduced value. */
12691 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12694 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12696 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
12697 TMPL_ARG (targs
, level
, idx
);
12701 /* Verify that the results of unification with the parameter packs
12702 produce results consistent with what we've seen before, and make
12703 the deduced argument packs available. */
12704 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
12706 tree old_pack
= TREE_VALUE (pack
);
12707 tree new_args
= TREE_TYPE (pack
);
12708 int i
, len
= TREE_VEC_LENGTH (new_args
);
12709 bool nondeduced_p
= false;
12711 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
12712 actually deduce anything. */
12713 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
12714 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
12715 nondeduced_p
= true;
12719 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
12721 /* Prepend the explicit arguments onto NEW_ARGS. */
12722 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
12723 tree old_args
= new_args
;
12724 int i
, explicit_len
= TREE_VEC_LENGTH (explicit_args
);
12725 int len
= explicit_len
+ TREE_VEC_LENGTH (old_args
);
12727 /* Copy the explicit arguments. */
12728 new_args
= make_tree_vec (len
);
12729 for (i
= 0; i
< explicit_len
; i
++)
12730 TREE_VEC_ELT (new_args
, i
) = TREE_VEC_ELT (explicit_args
, i
);
12732 /* Copy the deduced arguments. */
12733 for (; i
< len
; i
++)
12734 TREE_VEC_ELT (new_args
, i
) =
12735 TREE_VEC_ELT (old_args
, i
- explicit_len
);
12743 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12745 /* Build the deduced *_ARGUMENT_PACK. */
12746 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
12748 result
= make_node (NONTYPE_ARGUMENT_PACK
);
12749 TREE_TYPE (result
) =
12750 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack
)));
12751 TREE_CONSTANT (result
) = 1;
12754 result
= make_node (TYPE_ARGUMENT_PACK
);
12756 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
12758 /* Note the deduced argument packs for this parameter
12760 TMPL_ARG (targs
, level
, idx
) = result
;
12762 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
12763 && (ARGUMENT_PACK_ARGS (old_pack
)
12764 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
12766 /* We only had the explicitly-provided arguments before, but
12767 now we have a complete set of arguments. */
12769 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
12770 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12772 /* Keep the original deduced argument pack. */
12773 TMPL_ARG (targs
, level
, idx
) = old_pack
;
12775 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
12776 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
12777 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
12779 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack
),
12781 /* Inconsistent unification of this parameter pack. */
12787 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
12789 /* Keep the original deduced argument pack. */
12790 TMPL_ARG (targs
, level
, idx
) = old_pack
;
12797 /* Deduce the value of template parameters. TPARMS is the (innermost)
12798 set of template parameters to a template. TARGS is the bindings
12799 for those template parameters, as determined thus far; TARGS may
12800 include template arguments for outer levels of template parameters
12801 as well. PARM is a parameter to a template function, or a
12802 subcomponent of that parameter; ARG is the corresponding argument.
12803 This function attempts to match PARM with ARG in a manner
12804 consistent with the existing assignments in TARGS. If more values
12805 are deduced, then TARGS is updated.
12807 Returns 0 if the type deduction succeeds, 1 otherwise. The
12808 parameter STRICT is a bitwise or of the following flags:
12811 Require an exact match between PARM and ARG.
12812 UNIFY_ALLOW_MORE_CV_QUAL:
12813 Allow the deduced ARG to be more cv-qualified (by qualification
12814 conversion) than ARG.
12815 UNIFY_ALLOW_LESS_CV_QUAL:
12816 Allow the deduced ARG to be less cv-qualified than ARG.
12817 UNIFY_ALLOW_DERIVED:
12818 Allow the deduced ARG to be a template base class of ARG,
12819 or a pointer to a template base class of the type pointed to by
12821 UNIFY_ALLOW_INTEGER:
12822 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12823 case for more information.
12824 UNIFY_ALLOW_OUTER_LEVEL:
12825 This is the outermost level of a deduction. Used to determine validity
12826 of qualification conversions. A valid qualification conversion must
12827 have const qualified pointers leading up to the inner type which
12828 requires additional CV quals, except at the outer level, where const
12829 is not required [conv.qual]. It would be normal to set this flag in
12830 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12831 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12832 This is the outermost level of a deduction, and PARM can be more CV
12833 qualified at this point.
12834 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12835 This is the outermost level of a deduction, and PARM can be less CV
12836 qualified at this point. */
12839 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
)
12844 int strict_in
= strict
;
12846 /* I don't think this will do the right thing with respect to types.
12847 But the only case I've seen it in so far has been array bounds, where
12848 signedness is the only information lost, and I think that will be
12850 while (TREE_CODE (parm
) == NOP_EXPR
)
12851 parm
= TREE_OPERAND (parm
, 0);
12853 if (arg
== error_mark_node
)
12855 if (arg
== unknown_type_node
)
12856 /* We can't deduce anything from this, but we might get all the
12857 template args from other function args. */
12860 /* If PARM uses template parameters, then we can't bail out here,
12861 even if ARG == PARM, since we won't record unifications for the
12862 template parameters. We might need them if we're trying to
12863 figure out which of two things is more specialized. */
12864 if (arg
== parm
&& !uses_template_parms (parm
))
12867 /* Immediately reject some pairs that won't unify because of
12868 cv-qualification mismatches. */
12869 if (TREE_CODE (arg
) == TREE_CODE (parm
)
12871 /* It is the elements of the array which hold the cv quals of an array
12872 type, and the elements might be template type parms. We'll check
12873 when we recurse. */
12874 && TREE_CODE (arg
) != ARRAY_TYPE
12875 /* We check the cv-qualifiers when unifying with template type
12876 parameters below. We want to allow ARG `const T' to unify with
12877 PARM `T' for example, when computing which of two templates
12878 is more specialized, for example. */
12879 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
12880 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
12883 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
12884 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
12885 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
12886 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
12887 strict
&= ~UNIFY_ALLOW_DERIVED
;
12888 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
12889 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
12891 switch (TREE_CODE (parm
))
12893 case TYPENAME_TYPE
:
12895 case UNBOUND_CLASS_TEMPLATE
:
12896 /* In a type which contains a nested-name-specifier, template
12897 argument values cannot be deduced for template parameters used
12898 within the nested-name-specifier. */
12901 case TEMPLATE_TYPE_PARM
:
12902 case TEMPLATE_TEMPLATE_PARM
:
12903 case BOUND_TEMPLATE_TEMPLATE_PARM
:
12904 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
12905 if (tparm
== error_mark_node
)
12908 if (TEMPLATE_TYPE_LEVEL (parm
)
12909 != template_decl_level (tparm
))
12910 /* The PARM is not one we're trying to unify. Just check
12911 to see if it matches ARG. */
12912 return (TREE_CODE (arg
) == TREE_CODE (parm
)
12913 && same_type_p (parm
, arg
)) ? 0 : 1;
12914 idx
= TEMPLATE_TYPE_IDX (parm
);
12915 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
12916 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
12918 /* Check for mixed types and values. */
12919 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
12920 && TREE_CODE (tparm
) != TYPE_DECL
)
12921 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
12922 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
12925 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12927 /* ARG must be constructed from a template class or a template
12928 template parameter. */
12929 if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
12930 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
12934 tree parmvec
= TYPE_TI_ARGS (parm
);
12935 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
12937 = DECL_INNERMOST_TEMPLATE_PARMS
12938 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm
));
12940 int parm_variadic_p
= 0;
12942 /* The resolution to DR150 makes clear that default
12943 arguments for an N-argument may not be used to bind T
12944 to a template template parameter with fewer than N
12945 parameters. It is not safe to permit the binding of
12946 default arguments as an extension, as that may change
12947 the meaning of a conforming program. Consider:
12949 struct Dense { static const unsigned int dim = 1; };
12951 template <template <typename> class View,
12953 void operator+(float, View<Block> const&);
12955 template <typename Block,
12956 unsigned int Dim = Block::dim>
12957 struct Lvalue_proxy { operator float() const; };
12961 Lvalue_proxy<Dense> p;
12966 Here, if Lvalue_proxy is permitted to bind to View, then
12967 the global operator+ will be used; if they are not, the
12968 Lvalue_proxy will be converted to float. */
12969 if (coerce_template_parms (parm_parms
,
12971 TYPE_TI_TEMPLATE (parm
),
12973 /*require_all_args=*/true,
12974 /*use_default_args=*/false)
12975 == error_mark_node
)
12978 /* Deduce arguments T, i from TT<T> or TT<i>.
12979 We check each element of PARMVEC and ARGVEC individually
12980 rather than the whole TREE_VEC since they can have
12981 different number of elements. */
12983 parmvec
= expand_template_argument_pack (parmvec
);
12984 argvec
= expand_template_argument_pack (argvec
);
12986 len
= TREE_VEC_LENGTH (parmvec
);
12988 /* Check if the parameters end in a pack, making them
12991 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
12992 parm_variadic_p
= 1;
12994 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
12997 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
12999 if (unify (tparms
, targs
,
13000 TREE_VEC_ELT (parmvec
, i
),
13001 TREE_VEC_ELT (argvec
, i
),
13006 if (parm_variadic_p
13007 && unify_pack_expansion (tparms
, targs
,
13010 /*call_args_p=*/false,
13014 arg
= TYPE_TI_TEMPLATE (arg
);
13016 /* Fall through to deduce template name. */
13019 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
13020 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
13022 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
13024 /* Simple cases: Value already set, does match or doesn't. */
13025 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
13032 /* If PARM is `const T' and ARG is only `int', we don't have
13033 a match unless we are allowing additional qualification.
13034 If ARG is `const int' and PARM is just `T' that's OK;
13035 that binds `const int' to `T'. */
13036 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
13040 /* Consider the case where ARG is `const volatile int' and
13041 PARM is `const T'. Then, T should be `volatile int'. */
13042 arg
= cp_build_qualified_type_real
13043 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
13044 if (arg
== error_mark_node
)
13047 /* Simple cases: Value already set, does match or doesn't. */
13048 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
13053 /* Make sure that ARG is not a variable-sized array. (Note
13054 that were talking about variable-sized arrays (like
13055 `int[n]'), rather than arrays of unknown size (like
13056 `int[]').) We'll get very confused by such a type since
13057 the bound of the array will not be computable in an
13058 instantiation. Besides, such types are not allowed in
13059 ISO C++, so we can do as we please here. */
13060 if (variably_modified_type_p (arg
, NULL_TREE
))
13064 /* If ARG is a parameter pack or an expansion, we cannot unify
13065 against it unless PARM is also a parameter pack. */
13066 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
13067 && !template_parameter_pack_p (parm
))
13070 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
13073 case TEMPLATE_PARM_INDEX
:
13074 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
13075 if (tparm
== error_mark_node
)
13078 if (TEMPLATE_PARM_LEVEL (parm
)
13079 != template_decl_level (tparm
))
13080 /* The PARM is not one we're trying to unify. Just check
13081 to see if it matches ARG. */
13082 return !(TREE_CODE (arg
) == TREE_CODE (parm
)
13083 && cp_tree_equal (parm
, arg
));
13085 idx
= TEMPLATE_PARM_IDX (parm
);
13086 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
13089 return !cp_tree_equal (targ
, arg
);
13091 /* [temp.deduct.type] If, in the declaration of a function template
13092 with a non-type template-parameter, the non-type
13093 template-parameter is used in an expression in the function
13094 parameter-list and, if the corresponding template-argument is
13095 deduced, the template-argument type shall match the type of the
13096 template-parameter exactly, except that a template-argument
13097 deduced from an array bound may be of any integral type.
13098 The non-type parameter might use already deduced type parameters. */
13099 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
13100 if (!TREE_TYPE (arg
))
13101 /* Template-parameter dependent expression. Just accept it for now.
13102 It will later be processed in convert_template_argument. */
13104 else if (same_type_p (TREE_TYPE (arg
), tparm
))
13106 else if ((strict
& UNIFY_ALLOW_INTEGER
)
13107 && (TREE_CODE (tparm
) == INTEGER_TYPE
13108 || TREE_CODE (tparm
) == BOOLEAN_TYPE
))
13109 /* Convert the ARG to the type of PARM; the deduced non-type
13110 template argument must exactly match the types of the
13111 corresponding parameter. */
13112 arg
= fold (build_nop (TREE_TYPE (parm
), arg
));
13113 else if (uses_template_parms (tparm
))
13114 /* We haven't deduced the type of this parameter yet. Try again
13120 /* If ARG is a parameter pack or an expansion, we cannot unify
13121 against it unless PARM is also a parameter pack. */
13122 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
13123 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
13126 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
13131 /* A pointer-to-member constant can be unified only with
13132 another constant. */
13133 if (TREE_CODE (arg
) != PTRMEM_CST
)
13136 /* Just unify the class member. It would be useless (and possibly
13137 wrong, depending on the strict flags) to unify also
13138 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13139 arg refer to the same variable, even if through different
13140 classes. For instance:
13142 struct A { int x; };
13145 Unification of &A::x and &B::x must succeed. */
13146 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
13147 PTRMEM_CST_MEMBER (arg
), strict
);
13152 if (TREE_CODE (arg
) != POINTER_TYPE
)
13155 /* [temp.deduct.call]
13157 A can be another pointer or pointer to member type that can
13158 be converted to the deduced A via a qualification
13159 conversion (_conv.qual_).
13161 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
13162 This will allow for additional cv-qualification of the
13163 pointed-to types if appropriate. */
13165 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
13166 /* The derived-to-base conversion only persists through one
13167 level of pointers. */
13168 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
13170 return unify (tparms
, targs
, TREE_TYPE (parm
),
13171 TREE_TYPE (arg
), strict
);
13174 case REFERENCE_TYPE
:
13175 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
13177 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
13178 strict
& UNIFY_ALLOW_MORE_CV_QUAL
);
13181 if (TREE_CODE (arg
) != ARRAY_TYPE
)
13183 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
13184 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
13186 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
13193 /* Our representation of array types uses "N - 1" as the
13194 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
13195 not an integer constant. We cannot unify arbitrarily
13196 complex expressions, so we eliminate the MINUS_EXPRs
13198 parm_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (parm
));
13199 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
13202 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
13203 parm_max
= TREE_OPERAND (parm_max
, 0);
13205 arg_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (arg
));
13206 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
13209 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
13210 trying to unify the type of a variable with the type
13211 of a template parameter. For example:
13213 template <unsigned int N>
13214 void f (char (&) [N]);
13221 Here, the type of the ARG will be "int [g(i)]", and
13222 may be a SAVE_EXPR, etc. */
13223 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
13225 arg_max
= TREE_OPERAND (arg_max
, 0);
13228 /* If only one of the bounds used a MINUS_EXPR, compensate
13229 by adding one to the other bound. */
13230 if (parm_cst
&& !arg_cst
)
13231 parm_max
= fold_build2 (PLUS_EXPR
,
13235 else if (arg_cst
&& !parm_cst
)
13236 arg_max
= fold_build2 (PLUS_EXPR
,
13241 if (unify (tparms
, targs
, parm_max
, arg_max
, UNIFY_ALLOW_INTEGER
))
13244 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
13245 strict
& UNIFY_ALLOW_MORE_CV_QUAL
);
13252 case ENUMERAL_TYPE
:
13254 if (TREE_CODE (arg
) != TREE_CODE (parm
))
13257 /* We have already checked cv-qualification at the top of the
13259 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
13262 /* As far as unification is concerned, this wins. Later checks
13263 will invalidate it if necessary. */
13266 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
13267 /* Type INTEGER_CST can come from ordinary constant template args. */
13269 while (TREE_CODE (arg
) == NOP_EXPR
)
13270 arg
= TREE_OPERAND (arg
, 0);
13272 if (TREE_CODE (arg
) != INTEGER_CST
)
13274 return !tree_int_cst_equal (parm
, arg
);
13279 if (TREE_CODE (arg
) != TREE_VEC
)
13281 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
13283 for (i
= 0; i
< TREE_VEC_LENGTH (parm
); ++i
)
13284 if (unify (tparms
, targs
,
13285 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
13293 if (TREE_CODE (arg
) != TREE_CODE (parm
))
13296 if (TYPE_PTRMEMFUNC_P (parm
))
13298 if (!TYPE_PTRMEMFUNC_P (arg
))
13301 return unify (tparms
, targs
,
13302 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
13303 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
13307 if (CLASSTYPE_TEMPLATE_INFO (parm
))
13309 tree t
= NULL_TREE
;
13311 if (strict_in
& UNIFY_ALLOW_DERIVED
)
13313 /* First, we try to unify the PARM and ARG directly. */
13314 t
= try_class_unification (tparms
, targs
,
13319 /* Fallback to the special case allowed in
13320 [temp.deduct.call]:
13322 If P is a class, and P has the form
13323 template-id, then A can be a derived class of
13324 the deduced A. Likewise, if P is a pointer to
13325 a class of the form template-id, A can be a
13326 pointer to a derived class pointed to by the
13328 t
= get_template_base (tparms
, targs
, parm
, arg
);
13334 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
13335 && (CLASSTYPE_TI_TEMPLATE (parm
)
13336 == CLASSTYPE_TI_TEMPLATE (arg
)))
13337 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13338 Then, we should unify `int' and `U'. */
13341 /* There's no chance of unification succeeding. */
13344 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
13345 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
);
13347 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
13352 case FUNCTION_TYPE
:
13353 if (TREE_CODE (arg
) != TREE_CODE (parm
))
13356 /* CV qualifications for methods can never be deduced, they must
13357 match exactly. We need to check them explicitly here,
13358 because type_unification_real treats them as any other
13359 cvqualified parameter. */
13360 if (TREE_CODE (parm
) == METHOD_TYPE
13361 && (!check_cv_quals_for_unify
13363 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg
))),
13364 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm
))))))
13367 if (unify (tparms
, targs
, TREE_TYPE (parm
),
13368 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
))
13370 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
13371 TYPE_ARG_TYPES (arg
), 1, DEDUCE_EXACT
,
13375 /* Unify a pointer to member with a pointer to member function, which
13376 deduces the type of the member as a function type. */
13377 if (TYPE_PTRMEMFUNC_P (arg
))
13381 cp_cv_quals cv_quals
;
13383 /* Check top-level cv qualifiers */
13384 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
13387 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
13388 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
), UNIFY_ALLOW_NONE
))
13391 /* Determine the type of the function we are unifying against. */
13392 method_type
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg
));
13394 build_function_type (TREE_TYPE (method_type
),
13395 TREE_CHAIN (TYPE_ARG_TYPES (method_type
)));
13397 /* Extract the cv-qualifiers of the member function from the
13398 implicit object parameter and place them on the function
13399 type to be restored later. */
13401 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type
))));
13402 fntype
= build_qualified_type (fntype
, cv_quals
);
13403 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
);
13406 if (TREE_CODE (arg
) != OFFSET_TYPE
)
13408 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
13409 TYPE_OFFSET_BASETYPE (arg
), UNIFY_ALLOW_NONE
))
13411 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
13415 if (DECL_TEMPLATE_PARM_P (parm
))
13416 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
);
13417 if (arg
!= integral_constant_value (parm
))
13422 case TEMPLATE_DECL
:
13423 /* Matched cases are handled by the ARG == PARM test above. */
13426 case TYPE_ARGUMENT_PACK
:
13427 case NONTYPE_ARGUMENT_PACK
:
13429 tree packed_parms
= ARGUMENT_PACK_ARGS (parm
);
13430 tree packed_args
= ARGUMENT_PACK_ARGS (arg
);
13431 int i
, len
= TREE_VEC_LENGTH (packed_parms
);
13432 int argslen
= TREE_VEC_LENGTH (packed_args
);
13433 int parm_variadic_p
= 0;
13435 for (i
= 0; i
< len
; ++i
)
13437 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms
, i
)))
13440 /* We can unify against something with a trailing
13442 parm_variadic_p
= 1;
13444 /* Since there is something following the pack
13445 expansion, we cannot unify this template argument
13452 /* If we don't have enough arguments to satisfy the parameters
13453 (not counting the pack expression at the end), or we have
13454 too many arguments for a parameter list that doesn't end in
13455 a pack expression, we can't unify. */
13456 if (argslen
< (len
- parm_variadic_p
)
13457 || (argslen
> len
&& !parm_variadic_p
))
13460 /* Unify all of the parameters that precede the (optional)
13461 pack expression. */
13462 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
13464 if (unify (tparms
, targs
, TREE_VEC_ELT (packed_parms
, i
),
13465 TREE_VEC_ELT (packed_args
, i
), strict
))
13469 if (parm_variadic_p
)
13470 return unify_pack_expansion (tparms
, targs
,
13471 packed_parms
, packed_args
,
13472 strict
, /*call_args_p=*/false,
13480 case DECLTYPE_TYPE
:
13481 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13486 /* Unification fails if we hit an error node. */
13490 gcc_assert (EXPR_P (parm
));
13492 /* We must be looking at an expression. This can happen with
13496 void foo(S<I>, S<I + 2>);
13498 This is a "nondeduced context":
13502 The nondeduced contexts are:
13504 --A type that is a template-id in which one or more of
13505 the template-arguments is an expression that references
13506 a template-parameter.
13508 In these cases, we assume deduction succeeded, but don't
13509 actually infer any unifications. */
13511 if (!uses_template_parms (parm
)
13512 && !template_args_equal (parm
, arg
))
13519 /* Note that DECL can be defined in this translation unit, if
13523 mark_definable (tree decl
)
13526 DECL_NOT_REALLY_EXTERN (decl
) = 1;
13527 FOR_EACH_CLONE (clone
, decl
)
13528 DECL_NOT_REALLY_EXTERN (clone
) = 1;
13531 /* Called if RESULT is explicitly instantiated, or is a member of an
13532 explicitly instantiated class. */
13535 mark_decl_instantiated (tree result
, int extern_p
)
13537 SET_DECL_EXPLICIT_INSTANTIATION (result
);
13539 /* If this entity has already been written out, it's too late to
13540 make any modifications. */
13541 if (TREE_ASM_WRITTEN (result
))
13544 if (TREE_CODE (result
) != FUNCTION_DECL
)
13545 /* The TREE_PUBLIC flag for function declarations will have been
13546 set correctly by tsubst. */
13547 TREE_PUBLIC (result
) = 1;
13549 /* This might have been set by an earlier implicit instantiation. */
13550 DECL_COMDAT (result
) = 0;
13553 DECL_NOT_REALLY_EXTERN (result
) = 0;
13556 mark_definable (result
);
13557 /* Always make artificials weak. */
13558 if (DECL_ARTIFICIAL (result
) && flag_weak
)
13559 comdat_linkage (result
);
13560 /* For WIN32 we also want to put explicit instantiations in
13561 linkonce sections. */
13562 else if (TREE_PUBLIC (result
))
13563 maybe_make_one_only (result
);
13566 /* If EXTERN_P, then this function will not be emitted -- unless
13567 followed by an explicit instantiation, at which point its linkage
13568 will be adjusted. If !EXTERN_P, then this function will be
13569 emitted here. In neither circumstance do we want
13570 import_export_decl to adjust the linkage. */
13571 DECL_INTERFACE_KNOWN (result
) = 1;
13574 /* Given two function templates PAT1 and PAT2, return:
13576 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
13577 -1 if PAT2 is more specialized than PAT1.
13578 0 if neither is more specialized.
13580 LEN indicates the number of parameters we should consider
13581 (defaulted parameters should not be considered).
13583 The 1998 std underspecified function template partial ordering, and
13584 DR214 addresses the issue. We take pairs of arguments, one from
13585 each of the templates, and deduce them against each other. One of
13586 the templates will be more specialized if all the *other*
13587 template's arguments deduce against its arguments and at least one
13588 of its arguments *does* *not* deduce against the other template's
13589 corresponding argument. Deduction is done as for class templates.
13590 The arguments used in deduction have reference and top level cv
13591 qualifiers removed. Iff both arguments were originally reference
13592 types *and* deduction succeeds in both directions, the template
13593 with the more cv-qualified argument wins for that pairing (if
13594 neither is more cv-qualified, they both are equal). Unlike regular
13595 deduction, after all the arguments have been deduced in this way,
13596 we do *not* verify the deduced template argument values can be
13597 substituted into non-deduced contexts, nor do we have to verify
13598 that all template arguments have been deduced. */
13601 more_specialized_fn (tree pat1
, tree pat2
, int len
)
13603 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
13604 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
13605 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
13606 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
13607 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
13608 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
13609 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
13610 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
13614 /* Remove the this parameter from non-static member functions. If
13615 one is a non-static member function and the other is not a static
13616 member function, remove the first parameter from that function
13617 also. This situation occurs for operator functions where we
13618 locate both a member function (with this pointer) and non-member
13619 operator (with explicit first operand). */
13620 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
13622 len
--; /* LEN is the number of significant arguments for DECL1 */
13623 args1
= TREE_CHAIN (args1
);
13624 if (!DECL_STATIC_FUNCTION_P (decl2
))
13625 args2
= TREE_CHAIN (args2
);
13627 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
13629 args2
= TREE_CHAIN (args2
);
13630 if (!DECL_STATIC_FUNCTION_P (decl1
))
13633 args1
= TREE_CHAIN (args1
);
13637 /* If only one is a conversion operator, they are unordered. */
13638 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
13641 /* Consider the return type for a conversion function */
13642 if (DECL_CONV_FN_P (decl1
))
13644 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
13645 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
13649 processing_template_decl
++;
13653 tree arg1
= TREE_VALUE (args1
);
13654 tree arg2
= TREE_VALUE (args2
);
13655 int deduce1
, deduce2
;
13659 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
13660 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13662 /* When both arguments are pack expansions, we need only
13663 unify the patterns themselves. */
13664 arg1
= PACK_EXPANSION_PATTERN (arg1
);
13665 arg2
= PACK_EXPANSION_PATTERN (arg2
);
13667 /* This is the last comparison we need to do. */
13671 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
13673 arg1
= TREE_TYPE (arg1
);
13674 quals1
= cp_type_quals (arg1
);
13677 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
13679 arg2
= TREE_TYPE (arg2
);
13680 quals2
= cp_type_quals (arg2
);
13683 if ((quals1
< 0) != (quals2
< 0))
13685 /* Only of the args is a reference, see if we should apply
13686 array/function pointer decay to it. This is not part of
13687 DR214, but is, IMHO, consistent with the deduction rules
13688 for the function call itself, and with our earlier
13689 implementation of the underspecified partial ordering
13690 rules. (nathan). */
13693 switch (TREE_CODE (arg1
))
13696 arg1
= TREE_TYPE (arg1
);
13698 case FUNCTION_TYPE
:
13699 arg1
= build_pointer_type (arg1
);
13708 switch (TREE_CODE (arg2
))
13711 arg2
= TREE_TYPE (arg2
);
13713 case FUNCTION_TYPE
:
13714 arg2
= build_pointer_type (arg2
);
13723 arg1
= TYPE_MAIN_VARIANT (arg1
);
13724 arg2
= TYPE_MAIN_VARIANT (arg2
);
13726 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
13728 int i
, len2
= list_length (args2
);
13729 tree parmvec
= make_tree_vec (1);
13730 tree argvec
= make_tree_vec (len2
);
13733 /* Setup the parameter vector, which contains only ARG1. */
13734 TREE_VEC_ELT (parmvec
, 0) = arg1
;
13736 /* Setup the argument vector, which contains the remaining
13738 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
13739 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
13741 deduce1
= !unify_pack_expansion (tparms1
, targs1
, parmvec
,
13742 argvec
, UNIFY_ALLOW_NONE
,
13743 /*call_args_p=*/false,
13746 /* We cannot deduce in the other direction, because ARG1 is
13747 a pack expansion but ARG2 is not. */
13750 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13752 int i
, len1
= list_length (args1
);
13753 tree parmvec
= make_tree_vec (1);
13754 tree argvec
= make_tree_vec (len1
);
13757 /* Setup the parameter vector, which contains only ARG1. */
13758 TREE_VEC_ELT (parmvec
, 0) = arg2
;
13760 /* Setup the argument vector, which contains the remaining
13762 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
13763 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
13765 deduce2
= !unify_pack_expansion (tparms2
, targs2
, parmvec
,
13766 argvec
, UNIFY_ALLOW_NONE
,
13767 /*call_args_p=*/false,
13770 /* We cannot deduce in the other direction, because ARG2 is
13771 a pack expansion but ARG1 is not.*/
13777 /* The normal case, where neither argument is a pack
13779 deduce1
= !unify (tparms1
, targs1
, arg1
, arg2
, UNIFY_ALLOW_NONE
);
13780 deduce2
= !unify (tparms2
, targs2
, arg2
, arg1
, UNIFY_ALLOW_NONE
);
13787 if (better1
< 0 && better2
< 0)
13788 /* We've failed to deduce something in either direction.
13789 These must be unordered. */
13792 if (deduce1
&& deduce2
&& quals1
>= 0 && quals2
>= 0)
13794 /* Deduces in both directions, see if quals can
13795 disambiguate. Pretend the worse one failed to deduce. */
13796 if ((quals1
& quals2
) == quals2
)
13798 if ((quals1
& quals2
) == quals1
)
13801 if (deduce1
&& !deduce2
&& !better2
)
13803 if (deduce2
&& !deduce1
&& !better1
)
13806 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
13807 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
13808 /* We have already processed all of the arguments in our
13809 handing of the pack expansion type. */
13812 args1
= TREE_CHAIN (args1
);
13813 args2
= TREE_CHAIN (args2
);
13815 /* Stop when an ellipsis is seen. */
13816 if (args1
== NULL_TREE
|| args2
== NULL_TREE
)
13820 processing_template_decl
--;
13822 /* All things being equal, if the next argument is a pack expansion
13823 for one function but not for the other, prefer the
13824 non-variadic function. */
13825 if ((better1
> 0) - (better2
> 0) == 0
13826 && args1
&& TREE_VALUE (args1
)
13827 && args2
&& TREE_VALUE (args2
))
13829 if (TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
)
13830 return TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
? 0 : -1;
13831 else if (TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
)
13835 return (better1
> 0) - (better2
> 0);
13838 /* Determine which of two partial specializations is more specialized.
13840 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13841 to the first partial specialization. The TREE_VALUE is the
13842 innermost set of template parameters for the partial
13843 specialization. PAT2 is similar, but for the second template.
13845 Return 1 if the first partial specialization is more specialized;
13846 -1 if the second is more specialized; 0 if neither is more
13849 See [temp.class.order] for information about determining which of
13850 two templates is more specialized. */
13853 more_specialized_class (tree pat1
, tree pat2
)
13858 bool any_deductions
= false;
13860 tmpl1
= TREE_TYPE (pat1
);
13861 tmpl2
= TREE_TYPE (pat2
);
13863 /* Just like what happens for functions, if we are ordering between
13864 different class template specializations, we may encounter dependent
13865 types in the arguments, and we need our dependency check functions
13866 to behave correctly. */
13867 ++processing_template_decl
;
13868 targs
= get_class_bindings (TREE_VALUE (pat1
),
13869 CLASSTYPE_TI_ARGS (tmpl1
),
13870 CLASSTYPE_TI_ARGS (tmpl2
));
13874 any_deductions
= true;
13877 targs
= get_class_bindings (TREE_VALUE (pat2
),
13878 CLASSTYPE_TI_ARGS (tmpl2
),
13879 CLASSTYPE_TI_ARGS (tmpl1
));
13883 any_deductions
= true;
13885 --processing_template_decl
;
13887 /* In the case of a tie where at least one of the class templates
13888 has a parameter pack at the end, the template with the most
13889 non-packed parameters wins. */
13892 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
13893 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
13895 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
13896 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
13897 int len1
= TREE_VEC_LENGTH (args1
);
13898 int len2
= TREE_VEC_LENGTH (args2
);
13900 /* We don't count the pack expansion at the end. */
13901 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
13903 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
13908 else if (len1
< len2
)
13915 /* Return the template arguments that will produce the function signature
13916 DECL from the function template FN, with the explicit template
13917 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13918 also match. Return NULL_TREE if no satisfactory arguments could be
13922 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
13924 int ntparms
= DECL_NTPARMS (fn
);
13925 tree targs
= make_tree_vec (ntparms
);
13927 tree decl_arg_types
;
13929 /* Substitute the explicit template arguments into the type of DECL.
13930 The call to fn_type_unification will handle substitution into the
13932 decl_type
= TREE_TYPE (decl
);
13933 if (explicit_args
&& uses_template_parms (decl_type
))
13936 tree converted_args
;
13938 if (DECL_TEMPLATE_INFO (decl
))
13939 tmpl
= DECL_TI_TEMPLATE (decl
);
13941 /* We can get here for some invalid specializations. */
13945 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
13946 explicit_args
, NULL_TREE
,
13948 /*require_all_args=*/false,
13949 /*use_default_args=*/false);
13950 if (converted_args
== error_mark_node
)
13953 decl_type
= tsubst (decl_type
, converted_args
, tf_none
, NULL_TREE
);
13954 if (decl_type
== error_mark_node
)
13958 /* Never do unification on the 'this' parameter. */
13959 decl_arg_types
= skip_artificial_parms_for (decl
,
13960 TYPE_ARG_TYPES (decl_type
));
13962 if (fn_type_unification (fn
, explicit_args
, targs
,
13964 (check_rettype
|| DECL_CONV_FN_P (fn
)
13965 ? TREE_TYPE (decl_type
) : NULL_TREE
),
13966 DEDUCE_EXACT
, LOOKUP_NORMAL
))
13972 /* Return the innermost template arguments that, when applied to a
13973 template specialization whose innermost template parameters are
13974 TPARMS, and whose specialization arguments are PARMS, yield the
13977 For example, suppose we have:
13979 template <class T, class U> struct S {};
13980 template <class T> struct S<T*, int> {};
13982 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13983 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13984 int}. The resulting vector will be {double}, indicating that `T'
13985 is bound to `double'. */
13988 get_class_bindings (tree tparms
, tree spec_args
, tree args
)
13990 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
13992 tree innermost_deduced_args
;
13994 innermost_deduced_args
= make_tree_vec (ntparms
);
13995 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
13997 deduced_args
= copy_node (args
);
13998 SET_TMPL_ARGS_LEVEL (deduced_args
,
13999 TMPL_ARGS_DEPTH (deduced_args
),
14000 innermost_deduced_args
);
14003 deduced_args
= innermost_deduced_args
;
14005 if (unify (tparms
, deduced_args
,
14006 INNERMOST_TEMPLATE_ARGS (spec_args
),
14007 INNERMOST_TEMPLATE_ARGS (args
),
14011 for (i
= 0; i
< ntparms
; ++i
)
14012 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
14015 /* Verify that nondeduced template arguments agree with the type
14016 obtained from argument deduction.
14020 struct A { typedef int X; };
14021 template <class T, class U> struct C {};
14022 template <class T> struct C<T, typename T::X> {};
14024 Then with the instantiation `C<A, int>', we can deduce that
14025 `T' is `A' but unify () does not check whether `typename T::X'
14027 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
14028 if (spec_args
== error_mark_node
14029 /* We only need to check the innermost arguments; the other
14030 arguments will always agree. */
14031 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args
),
14032 INNERMOST_TEMPLATE_ARGS (args
)))
14035 /* Now that we have bindings for all of the template arguments,
14036 ensure that the arguments deduced for the template template
14037 parameters have compatible template parameter lists. See the use
14038 of template_template_parm_bindings_ok_p in fn_type_unification
14039 for more information. */
14040 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
14043 return deduced_args
;
14046 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
14047 Return the TREE_LIST node with the most specialized template, if
14048 any. If there is no most specialized template, the error_mark_node
14051 Note that this function does not look at, or modify, the
14052 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
14053 returned is one of the elements of INSTANTIATIONS, callers may
14054 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
14055 and retrieve it from the value returned. */
14058 most_specialized_instantiation (tree templates
)
14062 ++processing_template_decl
;
14065 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
14069 if (get_bindings (TREE_VALUE (champ
),
14070 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
14071 NULL_TREE
, /*check_ret=*/false))
14074 if (get_bindings (TREE_VALUE (fn
),
14075 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
14076 NULL_TREE
, /*check_ret=*/false))
14083 /* Equally specialized, move to next function. If there
14084 is no next function, nothing's most specialized. */
14085 fn
= TREE_CHAIN (fn
);
14093 /* Now verify that champ is better than everything earlier in the
14094 instantiation list. */
14095 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
))
14096 if (get_bindings (TREE_VALUE (champ
),
14097 DECL_TEMPLATE_RESULT (TREE_VALUE (fn
)),
14098 NULL_TREE
, /*check_ret=*/false)
14099 || !get_bindings (TREE_VALUE (fn
),
14100 DECL_TEMPLATE_RESULT (TREE_VALUE (champ
)),
14101 NULL_TREE
, /*check_ret=*/false))
14107 processing_template_decl
--;
14110 return error_mark_node
;
14115 /* If DECL is a specialization of some template, return the most
14116 general such template. Otherwise, returns NULL_TREE.
14118 For example, given:
14120 template <class T> struct S { template <class U> void f(U); };
14122 if TMPL is `template <class U> void S<int>::f(U)' this will return
14123 the full template. This function will not trace past partial
14124 specializations, however. For example, given in addition:
14126 template <class T> struct S<T*> { template <class U> void f(U); };
14128 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14129 `template <class T> template <class U> S<T*>::f(U)'. */
14132 most_general_template (tree decl
)
14134 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
14135 an immediate specialization. */
14136 if (TREE_CODE (decl
) == FUNCTION_DECL
)
14138 if (DECL_TEMPLATE_INFO (decl
)) {
14139 decl
= DECL_TI_TEMPLATE (decl
);
14141 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
14142 template friend. */
14143 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
14149 /* Look for more and more general templates. */
14150 while (DECL_TEMPLATE_INFO (decl
))
14152 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
14153 (See cp-tree.h for details.) */
14154 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
14157 if (CLASS_TYPE_P (TREE_TYPE (decl
))
14158 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
14161 /* Stop if we run into an explicitly specialized class template. */
14162 if (!DECL_NAMESPACE_SCOPE_P (decl
)
14163 && DECL_CONTEXT (decl
)
14164 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
14167 decl
= DECL_TI_TEMPLATE (decl
);
14173 /* Return the most specialized of the class template partial
14174 specializations of TMPL which can produce TYPE, a specialization of
14175 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
14176 a _TYPE node corresponding to the partial specialization, while the
14177 TREE_PURPOSE is the set of template arguments that must be
14178 substituted into the TREE_TYPE in order to generate TYPE.
14180 If the choice of partial specialization is ambiguous, a diagnostic
14181 is issued, and the error_mark_node is returned. If there are no
14182 partial specializations of TMPL matching TYPE, then NULL_TREE is
14186 most_specialized_class (tree type
, tree tmpl
)
14188 tree list
= NULL_TREE
;
14194 tree outer_args
= NULL_TREE
;
14196 tmpl
= most_general_template (tmpl
);
14197 args
= CLASSTYPE_TI_ARGS (type
);
14199 /* For determining which partial specialization to use, only the
14200 innermost args are interesting. */
14201 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
14203 outer_args
= strip_innermost_template_args (args
, 1);
14204 args
= INNERMOST_TEMPLATE_ARGS (args
);
14207 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
14209 tree partial_spec_args
;
14211 tree parms
= TREE_VALUE (t
);
14213 partial_spec_args
= CLASSTYPE_TI_ARGS (TREE_TYPE (t
));
14218 ++processing_template_decl
;
14220 /* Discard the outer levels of args, and then substitute in the
14221 template args from the enclosing class. */
14222 partial_spec_args
= INNERMOST_TEMPLATE_ARGS (partial_spec_args
);
14223 partial_spec_args
= tsubst_template_args
14224 (partial_spec_args
, outer_args
, tf_none
, NULL_TREE
);
14226 /* PARMS already refers to just the innermost parms, but the
14227 template parms in partial_spec_args had their levels lowered
14228 by tsubst, so we need to do the same for the parm list. We
14229 can't just tsubst the TREE_VEC itself, as tsubst wants to
14230 treat a TREE_VEC as an argument vector. */
14231 parms
= copy_node (parms
);
14232 for (i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
14233 TREE_VEC_ELT (parms
, i
) =
14234 tsubst (TREE_VEC_ELT (parms
, i
), outer_args
, tf_none
, NULL_TREE
);
14236 --processing_template_decl
;
14238 spec_args
= get_class_bindings (parms
,
14244 spec_args
= add_to_template_args (outer_args
, spec_args
);
14245 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
14246 TREE_TYPE (list
) = TREE_TYPE (t
);
14253 ambiguous_p
= false;
14256 t
= TREE_CHAIN (t
);
14257 for (; t
; t
= TREE_CHAIN (t
))
14259 fate
= more_specialized_class (champ
, t
);
14266 t
= TREE_CHAIN (t
);
14269 ambiguous_p
= true;
14278 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
14280 fate
= more_specialized_class (champ
, t
);
14283 ambiguous_p
= true;
14290 const char *str
= "candidates are:";
14291 error ("ambiguous class template instantiation for %q#T", type
);
14292 for (t
= list
; t
; t
= TREE_CHAIN (t
))
14294 error ("%s %+#T", str
, TREE_TYPE (t
));
14297 return error_mark_node
;
14303 /* Explicitly instantiate DECL. */
14306 do_decl_instantiation (tree decl
, tree storage
)
14308 tree result
= NULL_TREE
;
14311 if (!decl
|| decl
== error_mark_node
)
14312 /* An error occurred, for which grokdeclarator has already issued
14313 an appropriate message. */
14315 else if (! DECL_LANG_SPECIFIC (decl
))
14317 error ("explicit instantiation of non-template %q#D", decl
);
14320 else if (TREE_CODE (decl
) == VAR_DECL
)
14322 /* There is an asymmetry here in the way VAR_DECLs and
14323 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14324 the latter, the DECL we get back will be marked as a
14325 template instantiation, and the appropriate
14326 DECL_TEMPLATE_INFO will be set up. This does not happen for
14327 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14328 should handle VAR_DECLs as it currently handles
14330 if (!DECL_CLASS_SCOPE_P (decl
))
14332 error ("%qD is not a static data member of a class template", decl
);
14335 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
14336 if (!result
|| TREE_CODE (result
) != VAR_DECL
)
14338 error ("no matching template for %qD found", decl
);
14341 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
14343 error ("type %qT for explicit instantiation %qD does not match "
14344 "declared type %qT", TREE_TYPE (result
), decl
,
14349 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
14351 error ("explicit instantiation of %q#D", decl
);
14357 /* Check for various error cases. Note that if the explicit
14358 instantiation is valid the RESULT will currently be marked as an
14359 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
14360 until we get here. */
14362 if (DECL_TEMPLATE_SPECIALIZATION (result
))
14364 /* DR 259 [temp.spec].
14366 Both an explicit instantiation and a declaration of an explicit
14367 specialization shall not appear in a program unless the explicit
14368 instantiation follows a declaration of the explicit specialization.
14370 For a given set of template parameters, if an explicit
14371 instantiation of a template appears after a declaration of an
14372 explicit specialization for that template, the explicit
14373 instantiation has no effect. */
14376 else if (DECL_EXPLICIT_INSTANTIATION (result
))
14380 No program shall explicitly instantiate any template more
14383 We check DECL_NOT_REALLY_EXTERN so as not to complain when
14384 the first instantiation was `extern' and the second is not,
14385 and EXTERN_P for the opposite case. */
14386 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
14387 pedwarn ("duplicate explicit instantiation of %q#D", result
);
14388 /* If an "extern" explicit instantiation follows an ordinary
14389 explicit instantiation, the template is instantiated. */
14393 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
14395 error ("no matching template for %qD found", result
);
14398 else if (!DECL_TEMPLATE_INFO (result
))
14400 pedwarn ("explicit instantiation of non-template %q#D", result
);
14404 if (storage
== NULL_TREE
)
14406 else if (storage
== ridpointers
[(int) RID_EXTERN
])
14408 if (pedantic
&& !in_system_header
)
14409 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
14414 error ("storage class %qD applied to template instantiation", storage
);
14416 check_explicit_instantiation_namespace (result
);
14417 mark_decl_instantiated (result
, extern_p
);
14419 instantiate_decl (result
, /*defer_ok=*/1,
14420 /*expl_inst_class_mem_p=*/false);
14424 mark_class_instantiated (tree t
, int extern_p
)
14426 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
14427 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
14428 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
14429 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
14432 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
14433 rest_of_type_compilation (t
, 1);
14437 /* Called from do_type_instantiation through binding_table_foreach to
14438 do recursive instantiation for the type bound in ENTRY. */
14440 bt_instantiate_type_proc (binding_entry entry
, void *data
)
14442 tree storage
= *(tree
*) data
;
14444 if (MAYBE_CLASS_TYPE_P (entry
->type
)
14445 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
14446 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
14449 /* Called from do_type_instantiation to instantiate a member
14450 (a member function or a static member variable) of an
14451 explicitly instantiated class template. */
14453 instantiate_class_member (tree decl
, int extern_p
)
14455 mark_decl_instantiated (decl
, extern_p
);
14457 instantiate_decl (decl
, /*defer_ok=*/1,
14458 /*expl_inst_class_mem_p=*/true);
14461 /* Perform an explicit instantiation of template class T. STORAGE, if
14462 non-null, is the RID for extern, inline or static. COMPLAIN is
14463 nonzero if this is called from the parser, zero if called recursively,
14464 since the standard is unclear (as detailed below). */
14467 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
14472 int previous_instantiation_extern_p
= 0;
14474 if (TREE_CODE (t
) == TYPE_DECL
)
14477 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
14479 error ("explicit instantiation of non-template type %qT", t
);
14485 if (!COMPLETE_TYPE_P (t
))
14487 if (complain
& tf_error
)
14488 error ("explicit instantiation of %q#T before definition of template",
14493 if (storage
!= NULL_TREE
)
14495 if (pedantic
&& !in_system_header
)
14496 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
14499 if (storage
== ridpointers
[(int) RID_INLINE
])
14501 else if (storage
== ridpointers
[(int) RID_EXTERN
])
14503 else if (storage
== ridpointers
[(int) RID_STATIC
])
14507 error ("storage class %qD applied to template instantiation",
14513 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
14515 /* DR 259 [temp.spec].
14517 Both an explicit instantiation and a declaration of an explicit
14518 specialization shall not appear in a program unless the explicit
14519 instantiation follows a declaration of the explicit specialization.
14521 For a given set of template parameters, if an explicit
14522 instantiation of a template appears after a declaration of an
14523 explicit specialization for that template, the explicit
14524 instantiation has no effect. */
14527 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
14531 No program shall explicitly instantiate any template more
14534 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
14535 instantiation was `extern'. If EXTERN_P then the second is.
14536 These cases are OK. */
14537 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
14539 if (!previous_instantiation_extern_p
&& !extern_p
14540 && (complain
& tf_error
))
14541 pedwarn ("duplicate explicit instantiation of %q#T", t
);
14543 /* If we've already instantiated the template, just return now. */
14544 if (!CLASSTYPE_INTERFACE_ONLY (t
))
14548 check_explicit_instantiation_namespace (TYPE_NAME (t
));
14549 mark_class_instantiated (t
, extern_p
);
14557 /* In contrast to implicit instantiation, where only the
14558 declarations, and not the definitions, of members are
14559 instantiated, we have here:
14563 The explicit instantiation of a class template specialization
14564 implies the instantiation of all of its members not
14565 previously explicitly specialized in the translation unit
14566 containing the explicit instantiation.
14568 Of course, we can't instantiate member template classes, since
14569 we don't have any arguments for them. Note that the standard
14570 is unclear on whether the instantiation of the members are
14571 *explicit* instantiations or not. However, the most natural
14572 interpretation is that it should be an explicit instantiation. */
14575 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
14576 if (TREE_CODE (tmp
) == FUNCTION_DECL
14577 && DECL_TEMPLATE_INSTANTIATION (tmp
))
14578 instantiate_class_member (tmp
, extern_p
);
14580 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
14581 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
14582 instantiate_class_member (tmp
, extern_p
);
14584 if (CLASSTYPE_NESTED_UTDS (t
))
14585 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
14586 bt_instantiate_type_proc
, &storage
);
14590 /* Given a function DECL, which is a specialization of TMPL, modify
14591 DECL to be a re-instantiation of TMPL with the same template
14592 arguments. TMPL should be the template into which tsubst'ing
14593 should occur for DECL, not the most general template.
14595 One reason for doing this is a scenario like this:
14598 void f(const T&, int i);
14600 void g() { f(3, 7); }
14603 void f(const T& t, const int i) { }
14605 Note that when the template is first instantiated, with
14606 instantiate_template, the resulting DECL will have no name for the
14607 first parameter, and the wrong type for the second. So, when we go
14608 to instantiate the DECL, we regenerate it. */
14611 regenerate_decl_from_template (tree decl
, tree tmpl
)
14613 /* The arguments used to instantiate DECL, from the most general
14618 args
= DECL_TI_ARGS (decl
);
14619 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
14621 /* Make sure that we can see identifiers, and compute access
14623 push_access_scope (decl
);
14625 if (TREE_CODE (decl
) == FUNCTION_DECL
)
14633 args_depth
= TMPL_ARGS_DEPTH (args
);
14634 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
14635 if (args_depth
> parms_depth
)
14636 args
= get_innermost_template_args (args
, parms_depth
);
14638 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
14639 args
, tf_error
, NULL_TREE
);
14641 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
14644 /* Merge parameter declarations. */
14645 decl_parm
= skip_artificial_parms_for (decl
,
14646 DECL_ARGUMENTS (decl
));
14648 = skip_artificial_parms_for (code_pattern
,
14649 DECL_ARGUMENTS (code_pattern
));
14650 while (decl_parm
&& !FUNCTION_PARAMETER_PACK_P (pattern_parm
))
14655 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
14656 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
14657 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
14659 parm_type
= type_decays_to (parm_type
);
14660 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
14661 TREE_TYPE (decl_parm
) = parm_type
;
14662 attributes
= DECL_ATTRIBUTES (pattern_parm
);
14663 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
14665 DECL_ATTRIBUTES (decl_parm
) = attributes
;
14666 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
14668 decl_parm
= TREE_CHAIN (decl_parm
);
14669 pattern_parm
= TREE_CHAIN (pattern_parm
);
14671 /* Merge any parameters that match with the function parameter
14673 if (pattern_parm
&& FUNCTION_PARAMETER_PACK_P (pattern_parm
))
14676 tree expanded_types
;
14677 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14678 the parameters in this function parameter pack. */
14679 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
14680 args
, tf_error
, NULL_TREE
);
14681 len
= TREE_VEC_LENGTH (expanded_types
);
14682 for (i
= 0; i
< len
; i
++)
14687 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
14688 /* Rename the parameter to include the index. */
14689 DECL_NAME (decl_parm
) =
14690 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
14691 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
14692 parm_type
= type_decays_to (parm_type
);
14693 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
14694 TREE_TYPE (decl_parm
) = parm_type
;
14695 attributes
= DECL_ATTRIBUTES (pattern_parm
);
14696 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
14698 DECL_ATTRIBUTES (decl_parm
) = attributes
;
14699 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
14701 decl_parm
= TREE_CHAIN (decl_parm
);
14704 /* Merge additional specifiers from the CODE_PATTERN. */
14705 if (DECL_DECLARED_INLINE_P (code_pattern
)
14706 && !DECL_DECLARED_INLINE_P (decl
))
14707 DECL_DECLARED_INLINE_P (decl
) = 1;
14708 if (DECL_INLINE (code_pattern
) && !DECL_INLINE (decl
))
14709 DECL_INLINE (decl
) = 1;
14711 else if (TREE_CODE (decl
) == VAR_DECL
)
14712 DECL_INITIAL (decl
) =
14713 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
14714 tf_error
, DECL_TI_TEMPLATE (decl
),
14715 /*integral_constant_expression_p=*/false);
14717 gcc_unreachable ();
14719 pop_access_scope (decl
);
14722 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14723 substituted to get DECL. */
14726 template_for_substitution (tree decl
)
14728 tree tmpl
= DECL_TI_TEMPLATE (decl
);
14730 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14731 for the instantiation. This is not always the most general
14732 template. Consider, for example:
14735 struct S { template <class U> void f();
14736 template <> void f<int>(); };
14738 and an instantiation of S<double>::f<int>. We want TD to be the
14739 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14740 while (/* An instantiation cannot have a definition, so we need a
14741 more general template. */
14742 DECL_TEMPLATE_INSTANTIATION (tmpl
)
14743 /* We must also deal with friend templates. Given:
14745 template <class T> struct S {
14746 template <class U> friend void f() {};
14749 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14750 so far as the language is concerned, but that's still
14751 where we get the pattern for the instantiation from. On
14752 other hand, if the definition comes outside the class, say:
14754 template <class T> struct S {
14755 template <class U> friend void f();
14757 template <class U> friend void f() {}
14759 we don't need to look any further. That's what the check for
14760 DECL_INITIAL is for. */
14761 || (TREE_CODE (decl
) == FUNCTION_DECL
14762 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
14763 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
14765 /* The present template, TD, should not be a definition. If it
14766 were a definition, we should be using it! Note that we
14767 cannot restructure the loop to just keep going until we find
14768 a template with a definition, since that might go too far if
14769 a specialization was declared, but not defined. */
14770 gcc_assert (TREE_CODE (decl
) != VAR_DECL
14771 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl
)));
14773 /* Fetch the more general template. */
14774 tmpl
= DECL_TI_TEMPLATE (tmpl
);
14780 /* Produce the definition of D, a _DECL generated from a template. If
14781 DEFER_OK is nonzero, then we don't have to actually do the
14782 instantiation now; we just have to do it sometime. Normally it is
14783 an error if this is an explicit instantiation but D is undefined.
14784 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14785 explicitly instantiated class template. */
14788 instantiate_decl (tree d
, int defer_ok
,
14789 bool expl_inst_class_mem_p
)
14791 tree tmpl
= DECL_TI_TEMPLATE (d
);
14798 bool pattern_defined
;
14800 location_t saved_loc
= input_location
;
14801 int saved_in_system_header
= in_system_header
;
14804 /* This function should only be used to instantiate templates for
14805 functions and static member variables. */
14806 gcc_assert (TREE_CODE (d
) == FUNCTION_DECL
14807 || TREE_CODE (d
) == VAR_DECL
);
14809 /* Variables are never deferred; if instantiation is required, they
14810 are instantiated right away. That allows for better code in the
14811 case that an expression refers to the value of the variable --
14812 if the variable has a constant value the referring expression can
14813 take advantage of that fact. */
14814 if (TREE_CODE (d
) == VAR_DECL
)
14817 /* Don't instantiate cloned functions. Instead, instantiate the
14818 functions they cloned. */
14819 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
14820 d
= DECL_CLONED_FUNCTION (d
);
14822 if (DECL_TEMPLATE_INSTANTIATED (d
))
14823 /* D has already been instantiated. It might seem reasonable to
14824 check whether or not D is an explicit instantiation, and, if so,
14825 stop here. But when an explicit instantiation is deferred
14826 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14827 is set, even though we still need to do the instantiation. */
14830 /* If we already have a specialization of this declaration, then
14831 there's no reason to instantiate it. Note that
14832 retrieve_specialization gives us both instantiations and
14833 specializations, so we must explicitly check
14834 DECL_TEMPLATE_SPECIALIZATION. */
14835 gen_tmpl
= most_general_template (tmpl
);
14836 gen_args
= DECL_TI_ARGS (d
);
14837 spec
= retrieve_specialization (gen_tmpl
, gen_args
,
14838 /*class_specializations_p=*/false);
14839 if (spec
!= NULL_TREE
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
14842 /* This needs to happen before any tsubsting. */
14843 if (! push_tinst_level (d
))
14846 timevar_push (TV_PARSE
);
14848 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14849 for the instantiation. */
14850 td
= template_for_substitution (d
);
14851 code_pattern
= DECL_TEMPLATE_RESULT (td
);
14853 /* We should never be trying to instantiate a member of a class
14854 template or partial specialization. */
14855 gcc_assert (d
!= code_pattern
);
14857 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
14858 || DECL_TEMPLATE_SPECIALIZATION (td
))
14859 /* In the case of a friend template whose definition is provided
14860 outside the class, we may have too many arguments. Drop the
14861 ones we don't need. The same is true for specializations. */
14862 args
= get_innermost_template_args
14863 (gen_args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
14867 if (TREE_CODE (d
) == FUNCTION_DECL
)
14868 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
);
14870 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
14872 /* We may be in the middle of deferred access check. Disable it now. */
14873 push_deferring_access_checks (dk_no_deferred
);
14875 /* Unless an explicit instantiation directive has already determined
14876 the linkage of D, remember that a definition is available for
14878 if (pattern_defined
14879 && !DECL_INTERFACE_KNOWN (d
)
14880 && !DECL_NOT_REALLY_EXTERN (d
))
14881 mark_definable (d
);
14883 input_location
= DECL_SOURCE_LOCATION (d
);
14884 in_system_header
= DECL_IN_SYSTEM_HEADER (d
);
14886 /* If D is a member of an explicitly instantiated class template,
14887 and no definition is available, treat it like an implicit
14889 if (!pattern_defined
&& expl_inst_class_mem_p
14890 && DECL_EXPLICIT_INSTANTIATION (d
))
14892 DECL_NOT_REALLY_EXTERN (d
) = 0;
14893 DECL_INTERFACE_KNOWN (d
) = 0;
14894 SET_DECL_IMPLICIT_INSTANTIATION (d
);
14899 /* Recheck the substitutions to obtain any warning messages
14900 about ignoring cv qualifiers. */
14901 tree gen
= DECL_TEMPLATE_RESULT (gen_tmpl
);
14902 tree type
= TREE_TYPE (gen
);
14904 /* Make sure that we can see identifiers, and compute access
14905 correctly. D is already the target FUNCTION_DECL with the
14907 push_access_scope (d
);
14909 if (TREE_CODE (gen
) == FUNCTION_DECL
)
14911 tsubst (DECL_ARGUMENTS (gen
), gen_args
, tf_warning_or_error
, d
);
14912 tsubst_exception_specification (type
, gen_args
, tf_warning_or_error
,
14914 /* Don't simply tsubst the function type, as that will give
14915 duplicate warnings about poor parameter qualifications.
14916 The function arguments are the same as the decl_arguments
14917 without the top level cv qualifiers. */
14918 type
= TREE_TYPE (type
);
14920 tsubst (type
, gen_args
, tf_warning_or_error
, d
);
14922 pop_access_scope (d
);
14925 /* Check to see whether we know that this template will be
14926 instantiated in some other file, as with "extern template"
14928 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
14929 /* In general, we do not instantiate such templates... */
14931 /* ... but we instantiate inline functions so that we can inline
14933 && ! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
))
14934 /* ... we instantiate static data members whose values are
14935 needed in integral constant expressions. */
14936 && ! (TREE_CODE (d
) == VAR_DECL
14937 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d
)))
14939 /* Defer all other templates, unless we have been explicitly
14940 forbidden from doing so. */
14941 if (/* If there is no definition, we cannot instantiate the
14944 /* If it's OK to postpone instantiation, do so. */
14946 /* If this is a static data member that will be defined
14947 elsewhere, we don't want to instantiate the entire data
14948 member, but we do want to instantiate the initializer so that
14949 we can substitute that elsewhere. */
14950 || (external_p
&& TREE_CODE (d
) == VAR_DECL
))
14952 /* The definition of the static data member is now required so
14953 we must substitute the initializer. */
14954 if (TREE_CODE (d
) == VAR_DECL
14955 && !DECL_INITIAL (d
)
14956 && DECL_INITIAL (code_pattern
))
14961 ns
= decl_namespace_context (d
);
14962 push_nested_namespace (ns
);
14963 push_nested_class (DECL_CONTEXT (d
));
14964 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
14966 tf_warning_or_error
, NULL_TREE
,
14967 /*integral_constant_expression_p=*/false);
14968 cp_finish_decl (d
, init
, /*init_const_expr_p=*/false,
14969 /*asmspec_tree=*/NULL_TREE
,
14970 LOOKUP_ONLYCONVERTING
);
14971 pop_nested_class ();
14972 pop_nested_namespace (ns
);
14975 /* We restore the source position here because it's used by
14976 add_pending_template. */
14977 input_location
= saved_loc
;
14979 if (at_eof
&& !pattern_defined
14980 && DECL_EXPLICIT_INSTANTIATION (d
))
14983 The definition of a non-exported function template, a
14984 non-exported member function template, or a non-exported
14985 member function or static data member of a class template
14986 shall be present in every translation unit in which it is
14987 explicitly instantiated. */
14989 ("explicit instantiation of %qD but no definition available", d
);
14991 /* ??? Historically, we have instantiated inline functions, even
14992 when marked as "extern template". */
14993 if (!(external_p
&& TREE_CODE (d
) == VAR_DECL
))
14994 add_pending_template (d
);
14997 /* Tell the repository that D is available in this translation unit
14998 -- and see if it is supposed to be instantiated here. */
14999 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
15001 /* In a PCH file, despite the fact that the repository hasn't
15002 requested instantiation in the PCH it is still possible that
15003 an instantiation will be required in a file that includes the
15006 add_pending_template (d
);
15007 /* Instantiate inline functions so that the inliner can do its
15008 job, even though we'll not be emitting a copy of this
15010 if (!(TREE_CODE (d
) == FUNCTION_DECL
15011 && flag_inline_trees
15012 && DECL_DECLARED_INLINE_P (d
)))
15016 need_push
= !cfun
|| !global_bindings_p ();
15018 push_to_top_level ();
15020 /* Mark D as instantiated so that recursive calls to
15021 instantiate_decl do not try to instantiate it again. */
15022 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
15024 /* Regenerate the declaration in case the template has been modified
15025 by a subsequent redeclaration. */
15026 regenerate_decl_from_template (d
, td
);
15028 /* We already set the file and line above. Reset them now in case
15029 they changed as a result of calling regenerate_decl_from_template. */
15030 input_location
= DECL_SOURCE_LOCATION (d
);
15032 if (TREE_CODE (d
) == VAR_DECL
)
15036 /* Clear out DECL_RTL; whatever was there before may not be right
15037 since we've reset the type of the declaration. */
15038 SET_DECL_RTL (d
, NULL_RTX
);
15039 DECL_IN_AGGR_P (d
) = 0;
15041 /* The initializer is placed in DECL_INITIAL by
15042 regenerate_decl_from_template. Pull it out so that
15043 finish_decl can process it. */
15044 init
= DECL_INITIAL (d
);
15045 DECL_INITIAL (d
) = NULL_TREE
;
15046 DECL_INITIALIZED_P (d
) = 0;
15048 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
15049 initializer. That function will defer actual emission until
15050 we have a chance to determine linkage. */
15051 DECL_EXTERNAL (d
) = 0;
15053 /* Enter the scope of D so that access-checking works correctly. */
15054 push_nested_class (DECL_CONTEXT (d
));
15055 finish_decl (d
, init
, NULL_TREE
);
15056 pop_nested_class ();
15058 else if (TREE_CODE (d
) == FUNCTION_DECL
)
15060 htab_t saved_local_specializations
;
15065 /* Save away the current list, in case we are instantiating one
15066 template from within the body of another. */
15067 saved_local_specializations
= local_specializations
;
15069 /* Set up the list of local specializations. */
15070 local_specializations
= htab_create (37,
15071 hash_local_specialization
,
15072 eq_local_specializations
,
15075 /* Set up context. */
15076 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
15078 /* Create substitution entries for the parameters. */
15079 subst_decl
= DECL_TEMPLATE_RESULT (template_for_substitution (d
));
15080 tmpl_parm
= DECL_ARGUMENTS (subst_decl
);
15081 spec_parm
= DECL_ARGUMENTS (d
);
15082 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d
))
15084 register_local_specialization (spec_parm
, tmpl_parm
);
15085 spec_parm
= skip_artificial_parms_for (d
, spec_parm
);
15086 tmpl_parm
= skip_artificial_parms_for (subst_decl
, tmpl_parm
);
15088 while (tmpl_parm
&& !FUNCTION_PARAMETER_PACK_P (tmpl_parm
))
15090 register_local_specialization (spec_parm
, tmpl_parm
);
15091 tmpl_parm
= TREE_CHAIN (tmpl_parm
);
15092 spec_parm
= TREE_CHAIN (spec_parm
);
15094 if (tmpl_parm
&& FUNCTION_PARAMETER_PACK_P (tmpl_parm
))
15096 /* Collect all of the extra "packed" parameters into an
15100 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
15101 tree argtypepack
= make_node (TYPE_ARGUMENT_PACK
);
15105 /* Count how many parameters remain. */
15106 for (t
= spec_parm
; t
; t
= TREE_CHAIN (t
))
15109 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
15110 parmvec
= make_tree_vec (len
);
15111 parmtypevec
= make_tree_vec (len
);
15112 for(i
= 0; i
< len
; i
++, spec_parm
= TREE_CHAIN (spec_parm
))
15114 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
15115 TREE_VEC_ELT (parmtypevec
, i
) = TREE_TYPE (spec_parm
);
15118 /* Build the argument packs. */
15119 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
15120 SET_ARGUMENT_PACK_ARGS (argtypepack
, parmtypevec
);
15121 TREE_TYPE (argpack
) = argtypepack
;
15123 /* Register the (value) argument pack as a specialization of
15124 TMPL_PARM, then move on. */
15125 register_local_specialization (argpack
, tmpl_parm
);
15126 tmpl_parm
= TREE_CHAIN (tmpl_parm
);
15128 gcc_assert (!spec_parm
);
15130 /* Substitute into the body of the function. */
15131 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
15132 tf_warning_or_error
, tmpl
,
15133 /*integral_constant_expression_p=*/false);
15135 /* Set the current input_location to the end of the function
15136 so that finish_function knows where we are. */
15137 input_location
= DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
15139 /* We don't need the local specializations any more. */
15140 htab_delete (local_specializations
);
15141 local_specializations
= saved_local_specializations
;
15143 /* Finish the function. */
15144 d
= finish_function (0);
15145 expand_or_defer_fn (d
);
15148 /* We're not deferring instantiation any more. */
15149 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
15152 pop_from_top_level ();
15155 input_location
= saved_loc
;
15156 in_system_header
= saved_in_system_header
;
15157 pop_deferring_access_checks ();
15158 pop_tinst_level ();
15160 timevar_pop (TV_PARSE
);
15165 /* Run through the list of templates that we wish we could
15166 instantiate, and instantiate any we can. RETRIES is the
15167 number of times we retry pending template instantiation. */
15170 instantiate_pending_templates (int retries
)
15173 location_t saved_loc
= input_location
;
15174 int saved_in_system_header
= in_system_header
;
15176 /* Instantiating templates may trigger vtable generation. This in turn
15177 may require further template instantiations. We place a limit here
15178 to avoid infinite loop. */
15179 if (pending_templates
&& retries
>= max_tinst_depth
)
15181 tree decl
= pending_templates
->tinst
->decl
;
15183 error ("template instantiation depth exceeds maximum of %d"
15184 " instantiating %q+D, possibly from virtual table generation"
15185 " (use -ftemplate-depth-NN to increase the maximum)",
15186 max_tinst_depth
, decl
);
15187 if (TREE_CODE (decl
) == FUNCTION_DECL
)
15188 /* Pretend that we defined it. */
15189 DECL_INITIAL (decl
) = error_mark_node
;
15195 struct pending_template
**t
= &pending_templates
;
15196 struct pending_template
*last
= NULL
;
15200 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
15201 bool complete
= false;
15203 if (TYPE_P (instantiation
))
15207 if (!COMPLETE_TYPE_P (instantiation
))
15209 instantiate_class_template (instantiation
);
15210 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
15211 for (fn
= TYPE_METHODS (instantiation
);
15213 fn
= TREE_CHAIN (fn
))
15214 if (! DECL_ARTIFICIAL (fn
))
15215 instantiate_decl (fn
,
15217 /*expl_inst_class_mem_p=*/false);
15218 if (COMPLETE_TYPE_P (instantiation
))
15222 complete
= COMPLETE_TYPE_P (instantiation
);
15226 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
15227 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
15230 = instantiate_decl (instantiation
,
15232 /*expl_inst_class_mem_p=*/false);
15233 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
15237 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
15238 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
15242 /* If INSTANTIATION has been instantiated, then we don't
15243 need to consider it again in the future. */
15251 current_tinst_level
= NULL
;
15253 last_pending_template
= last
;
15255 while (reconsider
);
15257 input_location
= saved_loc
;
15258 in_system_header
= saved_in_system_header
;
15261 /* Substitute ARGVEC into T, which is a list of initializers for
15262 either base class or a non-static data member. The TREE_PURPOSEs
15263 are DECLs, and the TREE_VALUEs are the initializer values. Used by
15264 instantiate_decl. */
15267 tsubst_initializer_list (tree t
, tree argvec
)
15269 tree inits
= NULL_TREE
;
15271 for (; t
; t
= TREE_CHAIN (t
))
15275 tree expanded_bases
= NULL_TREE
;
15276 tree expanded_arguments
= NULL_TREE
;
15279 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
15284 /* Expand the base class expansion type into separate base
15286 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
15287 tf_warning_or_error
,
15289 if (expanded_bases
== error_mark_node
)
15292 /* We'll be building separate TREE_LISTs of arguments for
15294 len
= TREE_VEC_LENGTH (expanded_bases
);
15295 expanded_arguments
= make_tree_vec (len
);
15296 for (i
= 0; i
< len
; i
++)
15297 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
15299 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15300 expand each argument in the TREE_VALUE of t. */
15301 expr
= make_node (EXPR_PACK_EXPANSION
);
15302 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
15303 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
15305 if (TREE_VALUE (t
) == void_type_node
)
15306 /* VOID_TYPE_NODE is used to indicate
15307 value-initialization. */
15309 for (i
= 0; i
< len
; i
++)
15310 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
15314 /* Substitute parameter packs into each argument in the
15316 in_base_initializer
= 1;
15317 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
15319 tree expanded_exprs
;
15321 /* Expand the argument. */
15322 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
15324 = tsubst_pack_expansion (expr
, argvec
,
15325 tf_warning_or_error
,
15328 /* Prepend each of the expanded expressions to the
15329 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15330 for (i
= 0; i
< len
; i
++)
15332 TREE_VEC_ELT (expanded_arguments
, i
) =
15333 tree_cons (NULL_TREE
,
15334 TREE_VEC_ELT (expanded_exprs
, i
),
15335 TREE_VEC_ELT (expanded_arguments
, i
));
15338 in_base_initializer
= 0;
15340 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15341 since we built them backwards. */
15342 for (i
= 0; i
< len
; i
++)
15344 TREE_VEC_ELT (expanded_arguments
, i
) =
15345 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
15350 for (i
= 0; i
< len
; ++i
)
15352 if (expanded_bases
)
15354 decl
= TREE_VEC_ELT (expanded_bases
, i
);
15355 decl
= expand_member_init (decl
);
15356 init
= TREE_VEC_ELT (expanded_arguments
, i
);
15360 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
15361 tf_warning_or_error
, NULL_TREE
);
15363 decl
= expand_member_init (decl
);
15364 if (decl
&& !DECL_P (decl
))
15365 in_base_initializer
= 1;
15367 init
= tsubst_expr (TREE_VALUE (t
), argvec
,
15368 tf_warning_or_error
, NULL_TREE
,
15369 /*integral_constant_expression_p=*/false);
15370 in_base_initializer
= 0;
15375 init
= build_tree_list (decl
, init
);
15376 TREE_CHAIN (init
) = inits
;
15384 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
15387 set_current_access_from_decl (tree decl
)
15389 if (TREE_PRIVATE (decl
))
15390 current_access_specifier
= access_private_node
;
15391 else if (TREE_PROTECTED (decl
))
15392 current_access_specifier
= access_protected_node
;
15394 current_access_specifier
= access_public_node
;
15397 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
15398 is the instantiation (which should have been created with
15399 start_enum) and ARGS are the template arguments to use. */
15402 tsubst_enum (tree tag
, tree newtag
, tree args
)
15406 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
15411 decl
= TREE_VALUE (e
);
15412 /* Note that in a template enum, the TREE_VALUE is the
15413 CONST_DECL, not the corresponding INTEGER_CST. */
15414 value
= tsubst_expr (DECL_INITIAL (decl
),
15415 args
, tf_warning_or_error
, NULL_TREE
,
15416 /*integral_constant_expression_p=*/true);
15418 /* Give this enumeration constant the correct access. */
15419 set_current_access_from_decl (decl
);
15421 /* Actually build the enumerator itself. */
15422 build_enumerator (DECL_NAME (decl
), value
, newtag
);
15425 finish_enum (newtag
);
15426 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
15427 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
15430 /* DECL is a FUNCTION_DECL that is a template specialization. Return
15431 its type -- but without substituting the innermost set of template
15432 arguments. So, innermost set of template parameters will appear in
15436 get_mostly_instantiated_function_type (tree decl
)
15444 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
15445 targs
= DECL_TI_ARGS (decl
);
15446 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
15447 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
15449 /* There should be as many levels of arguments as there are levels
15451 gcc_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
));
15453 fn_type
= TREE_TYPE (tmpl
);
15455 if (parm_depth
== 1)
15456 /* No substitution is necessary. */
15460 int i
, save_access_control
;
15463 /* Replace the innermost level of the TARGS with NULL_TREEs to
15464 let tsubst know not to substitute for those parameters. */
15465 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
15466 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
15467 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
15468 TMPL_ARGS_LEVEL (targs
, i
));
15469 SET_TMPL_ARGS_LEVEL (partial_args
,
15470 TMPL_ARGS_DEPTH (targs
),
15471 make_tree_vec (DECL_NTPARMS (tmpl
)));
15473 /* Disable access control as this function is used only during
15475 save_access_control
= flag_access_control
;
15476 flag_access_control
= 0;
15478 ++processing_template_decl
;
15479 /* Now, do the (partial) substitution to figure out the
15480 appropriate function type. */
15481 fn_type
= tsubst (fn_type
, partial_args
, tf_error
, NULL_TREE
);
15482 --processing_template_decl
;
15484 /* Substitute into the template parameters to obtain the real
15485 innermost set of parameters. This step is important if the
15486 innermost set of template parameters contains value
15487 parameters whose types depend on outer template parameters. */
15488 TREE_VEC_LENGTH (partial_args
)--;
15489 tparms
= tsubst_template_parms (tparms
, partial_args
, tf_error
);
15491 flag_access_control
= save_access_control
;
15497 /* Return truthvalue if we're processing a template different from
15498 the last one involved in diagnostics. */
15500 problematic_instantiation_changed (void)
15502 return last_template_error_tick
!= tinst_level_tick
;
15505 /* Remember current template involved in diagnostics. */
15507 record_last_problematic_instantiation (void)
15509 last_template_error_tick
= tinst_level_tick
;
15512 struct tinst_level
*
15513 current_instantiation (void)
15515 return current_tinst_level
;
15518 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15519 type. Return zero for ok, nonzero for disallowed. Issue error and
15520 warning messages under control of COMPLAIN. */
15523 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
15525 if (INTEGRAL_TYPE_P (type
))
15527 else if (POINTER_TYPE_P (type
))
15529 else if (TYPE_PTR_TO_MEMBER_P (type
))
15531 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
15533 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
15536 if (complain
& tf_error
)
15537 error ("%q#T is not a valid type for a template constant parameter", type
);
15541 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
15542 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
15545 dependent_type_p_r (tree type
)
15551 A type is dependent if it is:
15553 -- a template parameter. Template template parameters are types
15554 for us (since TYPE_P holds true for them) so we handle
15556 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
15557 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
15559 /* -- a qualified-id with a nested-name-specifier which contains a
15560 class-name that names a dependent type or whose unqualified-id
15561 names a dependent type. */
15562 if (TREE_CODE (type
) == TYPENAME_TYPE
)
15564 /* -- a cv-qualified type where the cv-unqualified type is
15566 type
= TYPE_MAIN_VARIANT (type
);
15567 /* -- a compound type constructed from any dependent type. */
15568 if (TYPE_PTR_TO_MEMBER_P (type
))
15569 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
15570 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
15572 else if (TREE_CODE (type
) == POINTER_TYPE
15573 || TREE_CODE (type
) == REFERENCE_TYPE
)
15574 return dependent_type_p (TREE_TYPE (type
));
15575 else if (TREE_CODE (type
) == FUNCTION_TYPE
15576 || TREE_CODE (type
) == METHOD_TYPE
)
15580 if (dependent_type_p (TREE_TYPE (type
)))
15582 for (arg_type
= TYPE_ARG_TYPES (type
);
15584 arg_type
= TREE_CHAIN (arg_type
))
15585 if (dependent_type_p (TREE_VALUE (arg_type
)))
15589 /* -- an array type constructed from any dependent type or whose
15590 size is specified by a constant expression that is
15591 value-dependent. */
15592 if (TREE_CODE (type
) == ARRAY_TYPE
)
15594 if (TYPE_DOMAIN (type
)
15595 && dependent_type_p (TYPE_DOMAIN (type
)))
15597 return dependent_type_p (TREE_TYPE (type
));
15599 else if (TREE_CODE (type
) == INTEGER_TYPE
15600 && !TREE_CONSTANT (TYPE_MAX_VALUE (type
)))
15602 /* If this is the TYPE_DOMAIN of an array type, consider it
15604 return (value_dependent_expression_p (TYPE_MAX_VALUE (type
))
15605 || type_dependent_expression_p (TYPE_MAX_VALUE (type
)));
15608 /* -- a template-id in which either the template name is a template
15610 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
15612 /* ... or any of the template arguments is a dependent type or
15613 an expression that is type-dependent or value-dependent. */
15614 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
15615 && (any_dependent_template_arguments_p
15616 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
15619 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
15620 argument of the `typeof' expression is not type-dependent, then
15621 it should already been have resolved. */
15622 if (TREE_CODE (type
) == TYPEOF_TYPE
15623 || TREE_CODE (type
) == DECLTYPE_TYPE
)
15626 /* A template argument pack is dependent if any of its packed
15628 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
15630 tree args
= ARGUMENT_PACK_ARGS (type
);
15631 int i
, len
= TREE_VEC_LENGTH (args
);
15632 for (i
= 0; i
< len
; ++i
)
15633 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
15637 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
15638 be template parameters. */
15639 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
15642 /* The standard does not specifically mention types that are local
15643 to template functions or local classes, but they should be
15644 considered dependent too. For example:
15646 template <int I> void f() {
15651 The size of `E' cannot be known until the value of `I' has been
15652 determined. Therefore, `E' must be considered dependent. */
15653 scope
= TYPE_CONTEXT (type
);
15654 if (scope
&& TYPE_P (scope
))
15655 return dependent_type_p (scope
);
15656 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
15657 return type_dependent_expression_p (scope
);
15659 /* Other types are non-dependent. */
15663 /* Returns TRUE if TYPE is dependent, in the sense of
15664 [temp.dep.type]. */
15667 dependent_type_p (tree type
)
15669 /* If there are no template parameters in scope, then there can't be
15670 any dependent types. */
15671 if (!processing_template_decl
)
15673 /* If we are not processing a template, then nobody should be
15674 providing us with a dependent type. */
15676 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
);
15680 /* If the type is NULL, we have not computed a type for the entity
15681 in question; in that case, the type is dependent. */
15685 /* Erroneous types can be considered non-dependent. */
15686 if (type
== error_mark_node
)
15689 /* If we have not already computed the appropriate value for TYPE,
15691 if (!TYPE_DEPENDENT_P_VALID (type
))
15693 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
15694 TYPE_DEPENDENT_P_VALID (type
) = 1;
15697 return TYPE_DEPENDENT_P (type
);
15700 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
15703 dependent_scope_ref_p (tree expression
, bool criterion (tree
))
15708 gcc_assert (TREE_CODE (expression
) == SCOPE_REF
);
15710 if (!TYPE_P (TREE_OPERAND (expression
, 0)))
15713 scope
= TREE_OPERAND (expression
, 0);
15714 name
= TREE_OPERAND (expression
, 1);
15718 An id-expression is type-dependent if it contains a
15719 nested-name-specifier that contains a class-name that names a
15721 /* The suggested resolution to Core Issue 2 implies that if the
15722 qualifying type is the current class, then we must peek
15725 && currently_open_class (scope
)
15726 && !criterion (name
))
15728 if (dependent_type_p (scope
))
15734 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15735 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15739 value_dependent_expression_p (tree expression
)
15741 if (!processing_template_decl
)
15744 /* A name declared with a dependent type. */
15745 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
15748 switch (TREE_CODE (expression
))
15750 case IDENTIFIER_NODE
:
15751 /* A name that has not been looked up -- must be dependent. */
15754 case TEMPLATE_PARM_INDEX
:
15755 /* A non-type template parm. */
15759 /* A non-type template parm. */
15760 if (DECL_TEMPLATE_PARM_P (expression
))
15762 return value_dependent_expression_p (DECL_INITIAL (expression
));
15765 /* A constant with integral or enumeration type and is initialized
15766 with an expression that is value-dependent. */
15767 if (DECL_INITIAL (expression
)
15768 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression
))
15769 && value_dependent_expression_p (DECL_INITIAL (expression
)))
15773 case DYNAMIC_CAST_EXPR
:
15774 case STATIC_CAST_EXPR
:
15775 case CONST_CAST_EXPR
:
15776 case REINTERPRET_CAST_EXPR
:
15778 /* These expressions are value-dependent if the type to which
15779 the cast occurs is dependent or the expression being casted
15780 is value-dependent. */
15782 tree type
= TREE_TYPE (expression
);
15784 if (dependent_type_p (type
))
15787 /* A functional cast has a list of operands. */
15788 expression
= TREE_OPERAND (expression
, 0);
15791 /* If there are no operands, it must be an expression such
15792 as "int()". This should not happen for aggregate types
15793 because it would form non-constant expressions. */
15794 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
15799 if (TREE_CODE (expression
) == TREE_LIST
)
15800 return any_value_dependent_elements_p (expression
);
15802 return value_dependent_expression_p (expression
);
15807 /* A `sizeof' expression is value-dependent if the operand is
15808 type-dependent or is a pack expansion. */
15809 expression
= TREE_OPERAND (expression
, 0);
15810 if (PACK_EXPANSION_P (expression
))
15812 else if (TYPE_P (expression
))
15813 return dependent_type_p (expression
);
15814 return type_dependent_expression_p (expression
);
15817 return dependent_scope_ref_p (expression
, value_dependent_expression_p
);
15819 case COMPONENT_REF
:
15820 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
15821 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
15824 /* A CALL_EXPR may appear in a constant expression if it is a
15825 call to a builtin function, e.g., __builtin_constant_p. All
15826 such calls are value-dependent. */
15829 case NONTYPE_ARGUMENT_PACK
:
15830 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15831 is value-dependent. */
15833 tree values
= ARGUMENT_PACK_ARGS (expression
);
15834 int i
, len
= TREE_VEC_LENGTH (values
);
15836 for (i
= 0; i
< len
; ++i
)
15837 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
15845 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
15846 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
))
15847 || (type2
? dependent_type_p (type2
) : false));
15851 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
15852 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
15855 /* A constant expression is value-dependent if any subexpression is
15856 value-dependent. */
15857 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
15859 case tcc_reference
:
15861 return (value_dependent_expression_p
15862 (TREE_OPERAND (expression
, 0)));
15864 case tcc_comparison
:
15866 return ((value_dependent_expression_p
15867 (TREE_OPERAND (expression
, 0)))
15868 || (value_dependent_expression_p
15869 (TREE_OPERAND (expression
, 1))));
15871 case tcc_expression
:
15875 for (i
= 0; i
< TREE_OPERAND_LENGTH (expression
); ++i
)
15876 /* In some cases, some of the operands may be missing.
15877 (For example, in the case of PREDECREMENT_EXPR, the
15878 amount to increment by may be missing.) That doesn't
15879 make the expression dependent. */
15880 if (TREE_OPERAND (expression
, i
)
15881 && (value_dependent_expression_p
15882 (TREE_OPERAND (expression
, i
))))
15892 /* The expression is not value-dependent. */
15896 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15897 [temp.dep.expr]. */
15900 type_dependent_expression_p (tree expression
)
15902 if (!processing_template_decl
)
15905 if (expression
== error_mark_node
)
15908 /* An unresolved name is always dependent. */
15909 if (TREE_CODE (expression
) == IDENTIFIER_NODE
15910 || TREE_CODE (expression
) == USING_DECL
)
15913 /* Some expression forms are never type-dependent. */
15914 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
15915 || TREE_CODE (expression
) == SIZEOF_EXPR
15916 || TREE_CODE (expression
) == ALIGNOF_EXPR
15917 || TREE_CODE (expression
) == TRAIT_EXPR
15918 || TREE_CODE (expression
) == TYPEID_EXPR
15919 || TREE_CODE (expression
) == DELETE_EXPR
15920 || TREE_CODE (expression
) == VEC_DELETE_EXPR
15921 || TREE_CODE (expression
) == THROW_EXPR
)
15924 /* The types of these expressions depends only on the type to which
15925 the cast occurs. */
15926 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
15927 || TREE_CODE (expression
) == STATIC_CAST_EXPR
15928 || TREE_CODE (expression
) == CONST_CAST_EXPR
15929 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
15930 || TREE_CODE (expression
) == CAST_EXPR
)
15931 return dependent_type_p (TREE_TYPE (expression
));
15933 /* The types of these expressions depends only on the type created
15934 by the expression. */
15935 if (TREE_CODE (expression
) == NEW_EXPR
15936 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
15938 /* For NEW_EXPR tree nodes created inside a template, either
15939 the object type itself or a TREE_LIST may appear as the
15941 tree type
= TREE_OPERAND (expression
, 1);
15942 if (TREE_CODE (type
) == TREE_LIST
)
15943 /* This is an array type. We need to check array dimensions
15945 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
15946 || value_dependent_expression_p
15947 (TREE_OPERAND (TREE_VALUE (type
), 1));
15949 return dependent_type_p (type
);
15952 if (TREE_CODE (expression
) == SCOPE_REF
15953 && dependent_scope_ref_p (expression
,
15954 type_dependent_expression_p
))
15957 if (TREE_CODE (expression
) == FUNCTION_DECL
15958 && DECL_LANG_SPECIFIC (expression
)
15959 && DECL_TEMPLATE_INFO (expression
)
15960 && (any_dependent_template_arguments_p
15961 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
15964 if (TREE_CODE (expression
) == TEMPLATE_DECL
15965 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
15968 if (TREE_CODE (expression
) == STMT_EXPR
)
15969 expression
= stmt_expr_value_expr (expression
);
15971 if (TREE_TYPE (expression
) == unknown_type_node
)
15973 if (TREE_CODE (expression
) == ADDR_EXPR
)
15974 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
15975 if (TREE_CODE (expression
) == COMPONENT_REF
15976 || TREE_CODE (expression
) == OFFSET_REF
)
15978 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
15980 expression
= TREE_OPERAND (expression
, 1);
15981 if (TREE_CODE (expression
) == IDENTIFIER_NODE
)
15984 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15985 if (TREE_CODE (expression
) == SCOPE_REF
)
15988 if (TREE_CODE (expression
) == BASELINK
)
15989 expression
= BASELINK_FUNCTIONS (expression
);
15991 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
15993 if (any_dependent_template_arguments_p
15994 (TREE_OPERAND (expression
, 1)))
15996 expression
= TREE_OPERAND (expression
, 0);
15998 gcc_assert (TREE_CODE (expression
) == OVERLOAD
15999 || TREE_CODE (expression
) == FUNCTION_DECL
);
16003 if (type_dependent_expression_p (OVL_CURRENT (expression
)))
16005 expression
= OVL_NEXT (expression
);
16010 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
16012 return (dependent_type_p (TREE_TYPE (expression
)));
16015 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
16016 contains a type-dependent expression. */
16019 any_type_dependent_arguments_p (const_tree args
)
16023 tree arg
= TREE_VALUE (args
);
16025 if (type_dependent_expression_p (arg
))
16027 args
= TREE_CHAIN (args
);
16032 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
16033 expressions) contains any value-dependent expressions. */
16036 any_value_dependent_elements_p (const_tree list
)
16038 for (; list
; list
= TREE_CHAIN (list
))
16039 if (value_dependent_expression_p (TREE_VALUE (list
)))
16045 /* Returns TRUE if the ARG (a template argument) is dependent. */
16048 dependent_template_arg_p (tree arg
)
16050 if (!processing_template_decl
)
16053 if (TREE_CODE (arg
) == TEMPLATE_DECL
16054 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
16055 return dependent_template_p (arg
);
16056 else if (ARGUMENT_PACK_P (arg
))
16058 tree args
= ARGUMENT_PACK_ARGS (arg
);
16059 int i
, len
= TREE_VEC_LENGTH (args
);
16060 for (i
= 0; i
< len
; ++i
)
16062 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
16068 else if (TYPE_P (arg
))
16069 return dependent_type_p (arg
);
16071 return (type_dependent_expression_p (arg
)
16072 || value_dependent_expression_p (arg
));
16075 /* Returns true if ARGS (a collection of template arguments) contains
16076 any types that require structural equality testing. */
16079 any_template_arguments_need_structural_equality_p (tree args
)
16086 if (args
== error_mark_node
)
16089 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
16091 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
16092 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
16094 tree arg
= TREE_VEC_ELT (level
, j
);
16095 tree packed_args
= NULL_TREE
;
16098 if (ARGUMENT_PACK_P (arg
))
16100 /* Look inside the argument pack. */
16101 packed_args
= ARGUMENT_PACK_ARGS (arg
);
16102 len
= TREE_VEC_LENGTH (packed_args
);
16105 for (k
= 0; k
< len
; ++k
)
16108 arg
= TREE_VEC_ELT (packed_args
, k
);
16110 if (error_operand_p (arg
))
16112 else if (TREE_CODE (arg
) == TEMPLATE_DECL
16113 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
16115 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
16117 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
16118 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
16127 /* Returns true if ARGS (a collection of template arguments) contains
16128 any dependent arguments. */
16131 any_dependent_template_arguments_p (const_tree args
)
16138 if (args
== error_mark_node
)
16141 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
16143 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
16144 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
16145 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
16152 /* Returns TRUE if the template TMPL is dependent. */
16155 dependent_template_p (tree tmpl
)
16157 if (TREE_CODE (tmpl
) == OVERLOAD
)
16161 if (dependent_template_p (OVL_FUNCTION (tmpl
)))
16163 tmpl
= OVL_CHAIN (tmpl
);
16168 /* Template template parameters are dependent. */
16169 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
16170 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
16172 /* So are names that have not been looked up. */
16173 if (TREE_CODE (tmpl
) == SCOPE_REF
16174 || TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
16176 /* So are member templates of dependent classes. */
16177 if (TYPE_P (CP_DECL_CONTEXT (tmpl
)))
16178 return dependent_type_p (DECL_CONTEXT (tmpl
));
16182 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
16185 dependent_template_id_p (tree tmpl
, tree args
)
16187 return (dependent_template_p (tmpl
)
16188 || any_dependent_template_arguments_p (args
));
16191 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
16192 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
16193 no such TYPE can be found. Note that this function peers inside
16194 uninstantiated templates and therefore should be used only in
16195 extremely limited situations. ONLY_CURRENT_P restricts this
16196 peering to the currently open classes hierarchy (which is required
16197 when comparing types). */
16200 resolve_typename_type (tree type
, bool only_current_p
)
16209 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
16211 scope
= TYPE_CONTEXT (type
);
16212 name
= TYPE_IDENTIFIER (type
);
16214 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
16215 it first before we can figure out what NAME refers to. */
16216 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
16217 scope
= resolve_typename_type (scope
, only_current_p
);
16218 /* If we don't know what SCOPE refers to, then we cannot resolve the
16220 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
16222 /* If the SCOPE is a template type parameter, we have no way of
16223 resolving the name. */
16224 if (TREE_CODE (scope
) == TEMPLATE_TYPE_PARM
)
16226 /* If the SCOPE is not the current instantiation, there's no reason
16227 to look inside it. */
16228 if (only_current_p
&& !currently_open_class (scope
))
16230 /* If SCOPE isn't the template itself, it will not have a valid
16231 TYPE_FIELDS list. */
16232 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
16233 /* scope is either the template itself or a compatible instantiation
16234 like X<T>, so look up the name in the original template. */
16235 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
16237 /* scope is a partial instantiation, so we can't do the lookup or we
16238 will lose the template arguments. */
16240 /* Enter the SCOPE so that name lookup will be resolved as if we
16241 were in the class definition. In particular, SCOPE will no
16242 longer be considered a dependent type. */
16243 pushed_scope
= push_scope (scope
);
16244 /* Look up the declaration. */
16245 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true);
16247 result
= NULL_TREE
;
16249 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
16250 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
16253 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == IDENTIFIER_NODE
16254 && TREE_CODE (decl
) == TYPE_DECL
)
16256 result
= TREE_TYPE (decl
);
16257 if (result
== error_mark_node
)
16258 result
= NULL_TREE
;
16260 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type
)) == TEMPLATE_ID_EXPR
16261 && DECL_CLASS_TEMPLATE_P (decl
))
16265 /* Obtain the template and the arguments. */
16266 tmpl
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 0);
16267 args
= TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type
), 1);
16268 /* Instantiate the template. */
16269 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
16270 /*entering_scope=*/0,
16271 tf_error
| tf_user
);
16272 if (result
== error_mark_node
)
16273 result
= NULL_TREE
;
16276 /* Leave the SCOPE. */
16278 pop_scope (pushed_scope
);
16280 /* If we failed to resolve it, return the original typename. */
16284 /* If lookup found a typename type, resolve that too. */
16285 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
16287 /* Ill-formed programs can cause infinite recursion here, so we
16288 must catch that. */
16289 TYPENAME_IS_RESOLVING_P (type
) = 1;
16290 result
= resolve_typename_type (result
, only_current_p
);
16291 TYPENAME_IS_RESOLVING_P (type
) = 0;
16294 /* Qualify the resulting type. */
16295 quals
= cp_type_quals (type
);
16297 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
16302 /* EXPR is an expression which is not type-dependent. Return a proxy
16303 for EXPR that can be used to compute the types of larger
16304 expressions containing EXPR. */
16307 build_non_dependent_expr (tree expr
)
16311 /* Preserve null pointer constants so that the type of things like
16312 "p == 0" where "p" is a pointer can be determined. */
16313 if (null_ptr_cst_p (expr
))
16315 /* Preserve OVERLOADs; the functions must be available to resolve
16318 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
16319 inner_expr
= stmt_expr_value_expr (inner_expr
);
16320 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
16321 inner_expr
= TREE_OPERAND (inner_expr
, 0);
16322 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
16323 inner_expr
= TREE_OPERAND (inner_expr
, 1);
16324 if (is_overloaded_fn (inner_expr
)
16325 || TREE_CODE (inner_expr
) == OFFSET_REF
)
16327 /* There is no need to return a proxy for a variable. */
16328 if (TREE_CODE (expr
) == VAR_DECL
)
16330 /* Preserve string constants; conversions from string constants to
16331 "char *" are allowed, even though normally a "const char *"
16332 cannot be used to initialize a "char *". */
16333 if (TREE_CODE (expr
) == STRING_CST
)
16335 /* Preserve arithmetic constants, as an optimization -- there is no
16336 reason to create a new node. */
16337 if (TREE_CODE (expr
) == INTEGER_CST
|| TREE_CODE (expr
) == REAL_CST
)
16339 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
16340 There is at least one place where we want to know that a
16341 particular expression is a throw-expression: when checking a ?:
16342 expression, there are special rules if the second or third
16343 argument is a throw-expression. */
16344 if (TREE_CODE (expr
) == THROW_EXPR
)
16347 if (TREE_CODE (expr
) == COND_EXPR
)
16348 return build3 (COND_EXPR
,
16350 TREE_OPERAND (expr
, 0),
16351 (TREE_OPERAND (expr
, 1)
16352 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
16353 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
16354 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
16355 if (TREE_CODE (expr
) == COMPOUND_EXPR
16356 && !COMPOUND_EXPR_OVERLOADED (expr
))
16357 return build2 (COMPOUND_EXPR
,
16359 TREE_OPERAND (expr
, 0),
16360 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
16362 /* If the type is unknown, it can't really be non-dependent */
16363 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
16365 /* Otherwise, build a NON_DEPENDENT_EXPR.
16367 REFERENCE_TYPEs are not stripped for expressions in templates
16368 because doing so would play havoc with mangling. Consider, for
16371 template <typename T> void f<T& g>() { g(); }
16373 In the body of "f", the expression for "g" will have
16374 REFERENCE_TYPE, even though the standard says that it should
16375 not. The reason is that we must preserve the syntactic form of
16376 the expression so that mangling (say) "f<g>" inside the body of
16377 "f" works out correctly. Therefore, the REFERENCE_TYPE is
16379 return build1 (NON_DEPENDENT_EXPR
, non_reference (TREE_TYPE (expr
)), expr
);
16382 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
16383 Return a new TREE_LIST with the various arguments replaced with
16384 equivalent non-dependent expressions. */
16387 build_non_dependent_args (tree args
)
16392 new_args
= NULL_TREE
;
16393 for (a
= args
; a
; a
= TREE_CHAIN (a
))
16394 new_args
= tree_cons (NULL_TREE
,
16395 build_non_dependent_expr (TREE_VALUE (a
)),
16397 return nreverse (new_args
);
16400 #include "gt-cp-pt.h"