1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 93-97, 1998, 1999 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
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". */
46 /* The type of functions taking a tree, and some additional data, and
48 typedef int (*tree_fn_t
) PROTO((tree
, void*));
50 extern struct obstack permanent_obstack
;
53 extern char *input_filename
;
55 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
56 instantiations have been deferred, either because their definitions
57 were not yet available, or because we were putting off doing the
58 work. The TREE_PURPOSE of each entry is a SRCLOC indicating where
59 the instantiate request occurred; the TREE_VALUE is a either a DECL
60 (for a function or static data member), or a TYPE (for a class)
61 indicating what we are hoping to instantiate. */
62 static tree pending_templates
;
63 static tree
*template_tail
= &pending_templates
;
65 static tree maybe_templates
;
66 static tree
*maybe_template_tail
= &maybe_templates
;
68 int processing_template_parmlist
;
69 static int template_header_count
;
71 static tree saved_trees
;
72 static varray_type inline_parm_levels
;
73 static size_t inline_parm_levels_used
;
75 #define obstack_chunk_alloc xmalloc
76 #define obstack_chunk_free free
78 #define UNIFY_ALLOW_NONE 0
79 #define UNIFY_ALLOW_MORE_CV_QUAL 1
80 #define UNIFY_ALLOW_LESS_CV_QUAL 2
81 #define UNIFY_ALLOW_DERIVED 4
82 #define UNIFY_ALLOW_INTEGER 8
84 #define GTB_VIA_VIRTUAL 1 /* The base class we are examining is
85 virtual, or a base class of a virtual
87 #define GTB_IGNORE_TYPE 2 /* We don't need to try to unify the current
88 type with the desired type. */
90 static int resolve_overloaded_unification
PROTO((tree
, tree
, tree
, tree
,
91 unification_kind_t
, int));
92 static int try_one_overload
PROTO((tree
, tree
, tree
, tree
, tree
,
93 unification_kind_t
, int));
94 static int unify
PROTO((tree
, tree
, tree
, tree
, int));
95 static void add_pending_template
PROTO((tree
));
96 static int push_tinst_level
PROTO((tree
));
97 static tree classtype_mangled_name
PROTO((tree
));
98 static char *mangle_class_name_for_template
PROTO((char *, tree
, tree
));
99 static tree tsubst_expr_values
PROTO((tree
, tree
));
100 static int list_eq
PROTO((tree
, tree
));
101 static tree get_class_bindings
PROTO((tree
, tree
, tree
));
102 static tree coerce_template_parms
PROTO((tree
, tree
, tree
, int, int));
103 static void tsubst_enum
PROTO((tree
, tree
, tree
));
104 static tree add_to_template_args
PROTO((tree
, tree
));
105 static tree add_outermost_template_args
PROTO((tree
, tree
));
106 static void maybe_adjust_types_for_deduction
PROTO((unification_kind_t
, tree
*,
108 static int type_unification_real
PROTO((tree
, tree
, tree
, tree
,
109 int, unification_kind_t
, int));
110 static void note_template_header
PROTO((int));
111 static tree maybe_fold_nontype_arg
PROTO((tree
));
112 static tree convert_nontype_argument
PROTO((tree
, tree
));
113 static tree convert_template_argument
PROTO ((tree
, tree
, tree
, int,
115 static tree get_bindings_overload
PROTO((tree
, tree
, tree
));
116 static int for_each_template_parm
PROTO((tree
, tree_fn_t
, void*));
117 static tree build_template_parm_index
PROTO((int, int, int, tree
, tree
));
118 static int inline_needs_template_parms
PROTO((tree
));
119 static void push_inline_template_parms_recursive
PROTO((tree
, int));
120 static tree retrieve_specialization
PROTO((tree
, tree
));
121 static tree retrieve_local_specialization
PROTO((tree
, tree
));
122 static tree register_specialization
PROTO((tree
, tree
, tree
));
123 static tree register_local_specialization
PROTO((tree
, tree
, tree
));
124 static int unregister_specialization
PROTO((tree
, tree
));
125 static tree reduce_template_parm_level
PROTO((tree
, tree
, int));
126 static tree build_template_decl
PROTO((tree
, tree
));
127 static int mark_template_parm
PROTO((tree
, void *));
128 static tree tsubst_friend_function
PROTO((tree
, tree
));
129 static tree tsubst_friend_class
PROTO((tree
, tree
));
130 static tree get_bindings_real
PROTO((tree
, tree
, tree
, int));
131 static int template_decl_level
PROTO((tree
));
132 static tree maybe_get_template_decl_from_type_decl
PROTO((tree
));
133 static int check_cv_quals_for_unify
PROTO((int, tree
, tree
));
134 static tree tsubst_template_arg_vector
PROTO((tree
, tree
, int));
135 static tree tsubst_template_parms
PROTO((tree
, tree
, int));
136 static void regenerate_decl_from_template
PROTO((tree
, tree
));
137 static tree most_specialized
PROTO((tree
, tree
, tree
));
138 static tree most_specialized_class
PROTO((tree
, tree
));
139 static void set_mangled_name_for_template_decl
PROTO((tree
));
140 static int template_class_depth_real
PROTO((tree
, int));
141 static tree tsubst_aggr_type
PROTO((tree
, tree
, int, tree
, int));
142 static tree tsubst_decl
PROTO((tree
, tree
, tree
, tree
));
143 static tree tsubst_arg_types
PROTO((tree
, tree
, int, tree
));
144 static tree tsubst_function_type
PROTO((tree
, tree
, int, tree
));
145 static void check_specialization_scope
PROTO((void));
146 static tree process_partial_specialization
PROTO((tree
));
147 static void set_current_access_from_decl
PROTO((tree
));
148 static void check_default_tmpl_args
PROTO((tree
, tree
, int, int));
149 static tree tsubst_call_declarator_parms
PROTO((tree
, tree
, int, tree
));
150 static tree get_template_base_recursive
PROTO((tree
, tree
,
151 tree
, tree
, tree
, int));
152 static tree get_template_base
PROTO((tree
, tree
, tree
, tree
));
153 static tree try_class_unification
PROTO((tree
, tree
, tree
, tree
));
154 static int coerce_template_template_parms
PROTO((tree
, tree
, int,
156 static tree determine_specialization
PROTO((tree
, tree
, tree
*, int));
157 static int template_args_equal
PROTO((tree
, tree
));
158 static void print_template_context
PROTO((int));
159 static void tsubst_default_arguments
PROTO((tree
));
161 /* We use TREE_VECs to hold template arguments. If there is only one
162 level of template arguments, then the TREE_VEC contains the
163 arguments directly. If there is more than one level of template
164 arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
165 containing the template arguments for a single level. The first
166 entry in the outer TREE_VEC is the outermost level of template
167 parameters; the last is the innermost.
169 It is incorrect to ever form a template argument vector containing
170 only one level of arguments, but which is a TREE_VEC containing as
171 its only entry the TREE_VEC for that level. */
173 /* Non-zero if the template arguments is actually a vector of vectors,
174 rather than just a vector. */
175 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
177 && TREE_CODE (NODE) == TREE_VEC \
178 && TREE_VEC_LENGTH (NODE) > 0 \
179 && TREE_VEC_ELT (NODE, 0) != NULL_TREE \
180 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
182 /* The depth of a template argument vector. When called directly by
183 the parser, we use a TREE_LIST rather than a TREE_VEC to represent
184 template arguments. In fact, we may even see NULL_TREE if there
185 are no template arguments. In both of those cases, there is only
186 one level of template arguments. */
187 #define TMPL_ARGS_DEPTH(NODE) \
188 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
190 /* The LEVELth level of the template ARGS. Note that template
191 parameter levels are indexed from 1, not from 0. */
192 #define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
193 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
194 ? TREE_VEC_ELT ((ARGS), (LEVEL) - 1) : ARGS)
196 /* Set the LEVELth level of the template ARGS to VAL. This macro does
197 not work with single-level argument vectors. */
198 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
199 (TREE_VEC_ELT ((ARGS), (LEVEL) - 1) = (VAL))
201 /* Accesses the IDXth parameter in the LEVELth level of the ARGS. */
202 #define TMPL_ARG(ARGS, LEVEL, IDX) \
203 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
205 /* Set the IDXth element in the LEVELth level of ARGS to VAL. This
206 macro does not work with single-level argument vectors. */
207 #define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \
208 (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL))
210 /* Given a single level of template arguments in NODE, return the
211 number of arguments. */
212 #define NUM_TMPL_ARGS(NODE) \
213 ((NODE) == NULL_TREE ? 0 \
214 : (TREE_CODE (NODE) == TREE_VEC \
215 ? TREE_VEC_LENGTH (NODE) : list_length (NODE)))
217 /* The number of levels of template parameters given by NODE. */
218 #define TMPL_PARMS_DEPTH(NODE) \
219 (TREE_INT_CST_HIGH (TREE_PURPOSE (NODE)))
221 /* Called once to initialize pt.c. */
226 ggc_add_tree_root (&pending_templates
, 1);
227 ggc_add_tree_root (&maybe_templates
, 1);
228 ggc_add_tree_root (&saved_trees
, 1);
231 /* Do any processing required when DECL (a member template declaration
232 using TEMPLATE_PARAMETERS as its innermost parameter list) is
233 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
234 it is a specialization, in which case the DECL itself is returned. */
237 finish_member_template_decl (decl
)
240 if (decl
== NULL_TREE
|| decl
== void_type_node
)
242 else if (decl
== error_mark_node
)
243 /* By returning NULL_TREE, the parser will just ignore this
244 declaration. We have already issued the error. */
246 else if (TREE_CODE (decl
) == TREE_LIST
)
248 /* Assume that the class is the only declspec. */
249 decl
= TREE_VALUE (decl
);
250 if (IS_AGGR_TYPE (decl
) && CLASSTYPE_TEMPLATE_INFO (decl
)
251 && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl
))
253 tree tmpl
= CLASSTYPE_TI_TEMPLATE (decl
);
254 check_member_template (tmpl
);
259 else if (DECL_TEMPLATE_INFO (decl
))
261 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
263 check_member_template (DECL_TI_TEMPLATE (decl
));
264 return DECL_TI_TEMPLATE (decl
);
270 cp_error ("invalid member template declaration `%D'", decl
);
272 return error_mark_node
;
275 /* Returns the template nesting level of the indicated class TYPE.
285 A<T>::B<U> has depth two, while A<T> has depth one.
286 Both A<T>::B<int> and A<int>::B<U> have depth one, if
287 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
290 This function is guaranteed to return 0 if passed NULL_TREE so
291 that, for example, `template_class_depth (current_class_type)' is
295 template_class_depth_real (type
, count_specializations
)
297 int count_specializations
;
302 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
303 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
304 ? DECL_REAL_CONTEXT (type
) : TYPE_CONTEXT (type
))
306 if (TREE_CODE (type
) != FUNCTION_DECL
)
308 if (CLASSTYPE_TEMPLATE_INFO (type
)
309 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
))
310 && ((count_specializations
311 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
312 || uses_template_parms (CLASSTYPE_TI_ARGS (type
))))
317 if (DECL_TEMPLATE_INFO (type
)
318 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type
))
319 && ((count_specializations
320 && DECL_TEMPLATE_SPECIALIZATION (type
))
321 || uses_template_parms (DECL_TI_ARGS (type
))))
329 /* Returns the template nesting level of the indicated class TYPE.
330 Like template_class_depth_real, but instantiations do not count in
334 template_class_depth (type
)
337 return template_class_depth_real (type
, /*count_specializations=*/0);
340 /* Returns 1 if processing DECL as part of do_pending_inlines
341 needs us to push template parms. */
344 inline_needs_template_parms (decl
)
347 if (! DECL_TEMPLATE_INFO (decl
))
350 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
351 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
354 /* Subroutine of maybe_begin_member_template_processing.
355 Push the template parms in PARMS, starting from LEVELS steps into the
356 chain, and ending at the beginning, since template parms are listed
360 push_inline_template_parms_recursive (parmlist
, levels
)
364 tree parms
= TREE_VALUE (parmlist
);
368 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
370 ++processing_template_decl
;
371 current_template_parms
372 = tree_cons (build_int_2 (0, processing_template_decl
),
373 parms
, current_template_parms
);
374 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
377 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
379 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
380 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (parm
)) == 'd', 0);
382 switch (TREE_CODE (parm
))
391 /* Make a CONST_DECL as is done in process_template_parm.
392 It is ugly that we recreate this here; the original
393 version built in process_template_parm is no longer
395 tree decl
= build_decl (CONST_DECL
, DECL_NAME (parm
),
397 SET_DECL_ARTIFICIAL (decl
);
398 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
399 DECL_TEMPLATE_PARM_P (decl
) = 1;
405 my_friendly_abort (0);
410 /* Restore the template parameter context for a member template or
411 a friend template defined in a class definition. */
414 maybe_begin_member_template_processing (decl
)
420 if (inline_needs_template_parms (decl
))
422 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
423 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
425 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
428 parms
= TREE_CHAIN (parms
);
431 push_inline_template_parms_recursive (parms
, levels
);
434 /* Remember how many levels of template parameters we pushed so that
435 we can pop them later. */
436 if (!inline_parm_levels
)
437 VARRAY_INT_INIT (inline_parm_levels
, 4, "inline_parm_levels");
438 if (inline_parm_levels_used
== inline_parm_levels
->num_elements
)
439 VARRAY_GROW (inline_parm_levels
, 2 * inline_parm_levels_used
);
440 VARRAY_INT (inline_parm_levels
, inline_parm_levels_used
) = levels
;
441 ++inline_parm_levels_used
;
444 /* Undo the effects of begin_member_template_processing. */
447 maybe_end_member_template_processing ()
451 if (!inline_parm_levels_used
)
454 --inline_parm_levels_used
;
456 i
< VARRAY_INT (inline_parm_levels
, inline_parm_levels_used
);
459 --processing_template_decl
;
460 current_template_parms
= TREE_CHAIN (current_template_parms
);
465 /* Returns non-zero iff T is a member template function. We must be
468 template <class T> class C { void f(); }
470 Here, f is a template function, and a member, but not a member
471 template. This function does not concern itself with the origin of
472 T, only its present state. So if we have
474 template <class T> class C { template <class U> void f(U); }
476 then neither C<int>::f<char> nor C<T>::f<double> is considered
477 to be a member template. But, `template <class U> void
478 C<int>::f(U)' is considered a member template. */
481 is_member_template (t
)
484 if (!DECL_FUNCTION_TEMPLATE_P (t
))
485 /* Anything that isn't a function or a template function is
486 certainly not a member template. */
489 /* A local class can't have member templates. */
490 if (hack_decl_function_context (t
))
493 return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t
))
494 /* If there are more levels of template parameters than
495 there are template classes surrounding the declaration,
496 then we have a member template. */
497 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
498 template_class_depth (DECL_CLASS_CONTEXT (t
))));
502 /* Returns non-zero iff T is a member template class. See
503 is_member_template for a description of what precisely constitutes
504 a member template. */
507 is_member_template_class (t
)
510 if (!DECL_CLASS_TEMPLATE_P (t
))
511 /* Anything that isn't a class template, is certainly not a member
515 if (!DECL_CLASS_SCOPE_P (t
))
516 /* Anything whose context isn't a class type is surely not a
520 /* If there are more levels of template parameters than there are
521 template classes surrounding the declaration, then we have a
523 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
524 template_class_depth (DECL_CONTEXT (t
)));
528 /* Return a new template argument vector which contains all of ARGS,
529 but has as its innermost set of arguments the EXTRA_ARGS. The
530 resulting vector will be built on a temporary obstack, and so must
531 be explicitly copied to the permanent obstack, if required. */
534 add_to_template_args (args
, extra_args
)
543 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
544 new_args
= make_temp_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
546 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
547 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
549 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
550 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
555 /* Like add_to_template_args, but only the outermost ARGS are added to
556 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
557 (EXTRA_ARGS) levels are added. This function is used to combine
558 the template arguments from a partial instantiation with the
559 template arguments used to attain the full instantiation from the
560 partial instantiation. */
563 add_outermost_template_args (args
, extra_args
)
569 /* If there are more levels of EXTRA_ARGS than there are ARGS,
570 something very fishy is going on. */
571 my_friendly_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
),
574 /* If *all* the new arguments will be the EXTRA_ARGS, just return
576 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
579 /* For the moment, we make ARGS look like it contains fewer levels. */
580 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
582 new_args
= add_to_template_args (args
, extra_args
);
584 /* Now, we restore ARGS to its full dimensions. */
585 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
590 /* We've got a template header coming up; push to a new level for storing
594 begin_template_parm_list ()
596 /* We use a non-tag-transparent scope here, which causes pushtag to
597 put tags in this scope, rather than in the enclosing class or
598 namespace scope. This is the right thing, since we want
599 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
600 global template class, push_template_decl handles putting the
601 TEMPLATE_DECL into top-level scope. For a nested template class,
604 template <class T> struct S1 {
605 template <class T> struct S2 {};
608 pushtag contains special code to call pushdecl_with_scope on the
609 TEMPLATE_DECL for S2. */
611 declare_pseudo_global_level ();
612 ++processing_template_decl
;
613 ++processing_template_parmlist
;
614 note_template_header (0);
617 /* This routine is called when a specialization is declared. If it is
618 illegal to declare a specialization here, an error is reported. */
621 check_specialization_scope ()
623 tree scope
= current_scope ();
627 An explicit specialization shall be declared in the namespace of
628 which the template is a member, or, for member templates, in the
629 namespace of which the enclosing class or enclosing class
630 template is a member. An explicit specialization of a member
631 function, member class or static data member of a class template
632 shall be declared in the namespace of which the class template
634 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
635 cp_error ("explicit specialization in non-namespace scope `%D'",
640 In an explicit specialization declaration for a member of a class
641 template or a member template that appears in namespace scope,
642 the member template and some of its enclosing class templates may
643 remain unspecialized, except that the declaration shall not
644 explicitly specialize a class member template if its enclosing
645 class templates are not explicitly specialized as well. */
646 if (current_template_parms
)
647 cp_error ("enclosing class templates are not explicitly specialized");
650 /* We've just seen template <>. */
653 begin_specialization ()
655 note_template_header (1);
656 check_specialization_scope ();
659 /* Called at then end of processing a declaration preceeded by
663 end_specialization ()
665 reset_specialization ();
668 /* Any template <>'s that we have seen thus far are not referring to a
669 function specialization. */
672 reset_specialization ()
674 processing_specialization
= 0;
675 template_header_count
= 0;
678 /* We've just seen a template header. If SPECIALIZATION is non-zero,
679 it was of the form template <>. */
682 note_template_header (specialization
)
685 processing_specialization
= specialization
;
686 template_header_count
++;
689 /* We're beginning an explicit instantiation. */
692 begin_explicit_instantiation ()
694 ++processing_explicit_instantiation
;
699 end_explicit_instantiation ()
701 my_friendly_assert(processing_explicit_instantiation
> 0, 0);
702 --processing_explicit_instantiation
;
705 /* The TYPE is being declared. If it is a template type, that means it
706 is a partial specialization. Do appropriate error-checking. */
709 maybe_process_partial_specialization (type
)
712 if (IS_AGGR_TYPE (type
) && CLASSTYPE_USE_TEMPLATE (type
))
714 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
715 && TYPE_SIZE (type
) == NULL_TREE
)
717 if (current_namespace
718 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type
)))
720 cp_pedwarn ("specializing `%#T' in different namespace", type
);
721 cp_pedwarn_at (" from definition of `%#D'",
722 CLASSTYPE_TI_TEMPLATE (type
));
724 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
725 if (processing_template_decl
)
726 push_template_decl (TYPE_MAIN_DECL (type
));
728 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
729 cp_error ("specialization of `%T' after instantiation", type
);
731 else if (processing_specialization
)
732 cp_error ("explicit specialization of non-template `%T'", type
);
735 /* Retrieve the specialization (in the sense of [temp.spec] - a
736 specialization is either an instantiation or an explicit
737 specialization) of TMPL for the given template ARGS. If there is
738 no such specialization, return NULL_TREE. The ARGS are a vector of
739 arguments, or a vector of vectors of arguments, in the case of
740 templates with more than one level of parameters. */
743 retrieve_specialization (tmpl
, args
)
749 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
751 /* There should be as many levels of arguments as there are
752 levels of parameters. */
753 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
754 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
757 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
760 if (comp_template_args (TREE_PURPOSE (s
), args
))
761 return TREE_VALUE (s
);
766 /* Like retrieve_speciailization, but for local declarations. FN is
767 the function in which we are looking for an instantiation. */
770 retrieve_local_specialization (tmpl
, fn
)
774 tree s
= purpose_member (fn
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
775 return s
? TREE_VALUE (s
) : NULL_TREE
;
778 /* Returns non-zero iff DECL is a specialization of TMPL. */
781 is_specialization_of (decl
, tmpl
)
787 if (TREE_CODE (decl
) == FUNCTION_DECL
)
791 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
797 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 0);
799 for (t
= TREE_TYPE (decl
);
801 t
= CLASSTYPE_USE_TEMPLATE (t
)
802 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
803 if (same_type_p (TYPE_MAIN_VARIANT (t
),
804 TYPE_MAIN_VARIANT (TREE_TYPE (tmpl
))))
811 /* Register the specialization SPEC as a specialization of TMPL with
812 the indicated ARGS. Returns SPEC, or an equivalent prior
813 declaration, if available. */
816 register_specialization (spec
, tmpl
, args
)
823 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
825 if (TREE_CODE (spec
) == FUNCTION_DECL
826 && uses_template_parms (DECL_TI_ARGS (spec
)))
827 /* This is the FUNCTION_DECL for a partial instantiation. Don't
828 register it; we want the corresponding TEMPLATE_DECL instead.
829 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
830 the more obvious `uses_template_parms (spec)' to avoid problems
831 with default function arguments. In particular, given
834 template <class T> void f(T t1, T t = T())
836 the default argument expression is not substituted for in an
837 instantiation unless and until it is actually needed. */
840 /* There should be as many levels of arguments as there are
841 levels of parameters. */
842 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
843 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
846 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
850 tree fn
= TREE_VALUE (s
);
852 /* We can sometimes try to re-register a specialization that we've
853 already got. In particular, regenerate_decl_from_template
854 calls duplicate_decls which will update the specialization
855 list. But, we'll still get called again here anyhow. It's
856 more convenient to simply allow this than to try to prevent it. */
859 else if (comp_template_args (TREE_PURPOSE (s
), args
))
861 if (DECL_TEMPLATE_SPECIALIZATION (spec
))
863 if (DECL_TEMPLATE_INSTANTIATION (fn
))
866 || DECL_EXPLICIT_INSTANTIATION (fn
))
868 cp_error ("specialization of %D after instantiation",
874 /* This situation should occur only if the first
875 specialization is an implicit instantiation,
876 the second is an explicit specialization, and
877 the implicit instantiation has not yet been
878 used. That situation can occur if we have
879 implicitly instantiated a member function and
880 then specialized it later.
882 We can also wind up here if a friend
883 declaration that looked like an instantiation
884 turns out to be a specialization:
886 template <class T> void foo(T);
887 class S { friend void foo<>(int) };
888 template <> void foo(int);
890 We transform the existing DECL in place so that
891 any pointers to it become pointers to the
894 If there was a definition for the template, but
895 not for the specialization, we want this to
896 look as if there is no definition, and vice
898 DECL_INITIAL (fn
) = NULL_TREE
;
899 duplicate_decls (spec
, fn
);
904 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
906 duplicate_decls (spec
, fn
);
913 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
914 = tree_cons (args
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
919 /* Unregister the specialization SPEC as a specialization of TMPL.
920 Returns nonzero if the SPEC was listed as a specialization of
924 unregister_specialization (spec
, tmpl
)
930 for (s
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
932 s
= &TREE_CHAIN (*s
))
933 if (TREE_VALUE (*s
) == spec
)
935 *s
= TREE_CHAIN (*s
);
942 /* Like register_specialization, but for local declarations. FN is
943 the function in which we are registering SPEC, an instantiation of
947 register_local_specialization (spec
, tmpl
, fn
)
952 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
953 = tree_cons (fn
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
958 /* Print the list of candidate FNS in an error message. */
961 print_candidates (fns
)
966 const char *str
= "candidates are:";
968 for (fn
= fns
; fn
!= NULL_TREE
; fn
= TREE_CHAIN (fn
))
972 for (f
= TREE_VALUE (fn
); f
; f
= OVL_NEXT (f
))
973 cp_error_at ("%s %+#D", str
, OVL_CURRENT (f
));
978 /* Returns the template (one of the functions given by TEMPLATE_ID)
979 which can be specialized to match the indicated DECL with the
980 explicit template args given in TEMPLATE_ID. The DECL may be
981 NULL_TREE if none is available. In that case, the functions in
982 TEMPLATE_ID are non-members.
984 If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a
985 specialization of a member template.
987 The template args (those explicitly specified and those deduced)
988 are output in a newly created vector *TARGS_OUT.
990 If it is impossible to determine the result, an error message is
991 issued. The error_mark_node is returned to indicate failure. */
994 determine_specialization (template_id
, decl
, targs_out
,
995 need_member_template
)
999 int need_member_template
;
1003 tree explicit_targs
;
1004 tree candidates
= NULL_TREE
;
1005 tree templates
= NULL_TREE
;
1007 *targs_out
= NULL_TREE
;
1009 if (template_id
== error_mark_node
)
1010 return error_mark_node
;
1012 fns
= TREE_OPERAND (template_id
, 0);
1013 explicit_targs
= TREE_OPERAND (template_id
, 1);
1015 if (fns
== error_mark_node
)
1016 return error_mark_node
;
1018 /* Check for baselinks. */
1019 if (BASELINK_P (fns
))
1020 fns
= TREE_VALUE (fns
);
1022 if (!is_overloaded_fn (fns
))
1024 cp_error ("`%D' is not a function template", fns
);
1025 return error_mark_node
;
1028 for (; fns
; fns
= OVL_NEXT (fns
))
1032 tree fn
= OVL_CURRENT (fns
);
1034 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1035 /* DECL might be a specialization of FN. */
1037 else if (need_member_template
)
1038 /* FN is an ordinary member function, and we need a
1039 specialization of a member template. */
1041 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
1042 /* We can get IDENTIFIER_NODEs here in certain erroneous
1045 else if (!DECL_FUNCTION_MEMBER_P (fn
))
1046 /* This is just an ordinary non-member function. Nothing can
1047 be a specialization of that. */
1051 tree decl_arg_types
;
1053 /* This is an ordinary member function. However, since
1054 we're here, we can assume it's enclosing class is a
1055 template class. For example,
1057 template <typename T> struct S { void f(); };
1058 template <> void S<int>::f() {}
1060 Here, S<int>::f is a non-template, but S<int> is a
1061 template class. If FN has the same type as DECL, we
1062 might be in business. */
1063 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
1064 TREE_TYPE (TREE_TYPE (fn
))))
1065 /* The return types differ. */
1068 /* Adjust the type of DECL in case FN is a static member. */
1069 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1070 if (DECL_STATIC_FUNCTION_P (fn
)
1071 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1072 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
1074 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1077 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1082 /* See whether this function might be a specialization of this
1084 targs
= get_bindings (tmpl
, decl
, explicit_targs
);
1087 /* We cannot deduce template arguments that when used to
1088 specialize TMPL will produce DECL. */
1091 /* Save this template, and the arguments deduced. */
1092 templates
= tree_cons (targs
, tmpl
, templates
);
1095 if (templates
&& TREE_CHAIN (templates
))
1101 It is possible for a specialization with a given function
1102 signature to be instantiated from more than one function
1103 template. In such cases, explicit specification of the
1104 template arguments must be used to uniquely identify the
1105 function template specialization being specialized.
1107 Note that here, there's no suggestion that we're supposed to
1108 determine which of the candidate templates is most
1109 specialized. However, we, also have:
1113 Partial ordering of overloaded function template
1114 declarations is used in the following contexts to select
1115 the function template to which a function template
1116 specialization refers:
1118 -- when an explicit specialization refers to a function
1121 So, we do use the partial ordering rules, at least for now.
1122 This extension can only serve to make illegal programs legal,
1123 so it's safe. And, there is strong anecdotal evidence that
1124 the committee intended the partial ordering rules to apply;
1125 the EDG front-end has that behavior, and John Spicer claims
1126 that the committee simply forgot to delete the wording in
1127 [temp.expl.spec]. */
1128 tree tmpl
= most_specialized (templates
, decl
, explicit_targs
);
1129 if (tmpl
&& tmpl
!= error_mark_node
)
1131 targs
= get_bindings (tmpl
, decl
, explicit_targs
);
1132 templates
= tree_cons (targs
, tmpl
, NULL_TREE
);
1136 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
1138 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
1140 return error_mark_node
;
1142 else if ((templates
&& TREE_CHAIN (templates
))
1143 || (candidates
&& TREE_CHAIN (candidates
))
1144 || (templates
&& candidates
))
1146 cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1148 chainon (candidates
, templates
);
1149 print_candidates (candidates
);
1150 return error_mark_node
;
1153 /* We have one, and exactly one, match. */
1156 /* It was a specialization of an ordinary member function in a
1158 *targs_out
= copy_node (DECL_TI_ARGS (TREE_VALUE (candidates
)));
1159 return DECL_TI_TEMPLATE (TREE_VALUE (candidates
));
1162 /* It was a specialization of a template. */
1163 targs
= DECL_TI_ARGS (DECL_RESULT (TREE_VALUE (templates
)));
1164 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
1166 *targs_out
= copy_node (targs
);
1167 SET_TMPL_ARGS_LEVEL (*targs_out
,
1168 TMPL_ARGS_DEPTH (*targs_out
),
1169 TREE_PURPOSE (templates
));
1172 *targs_out
= TREE_PURPOSE (templates
);
1173 return TREE_VALUE (templates
);
1176 /* Check to see if the function just declared, as indicated in
1177 DECLARATOR, and in DECL, is a specialization of a function
1178 template. We may also discover that the declaration is an explicit
1179 instantiation at this point.
1181 Returns DECL, or an equivalent declaration that should be used
1182 instead if all goes well. Issues an error message if something is
1183 amiss. Returns error_mark_node if the error is not easily
1186 FLAGS is a bitmask consisting of the following flags:
1188 2: The function has a definition.
1189 4: The function is a friend.
1191 The TEMPLATE_COUNT is the number of references to qualifying
1192 template classes that appeared in the name of the function. For
1195 template <class T> struct S { void f(); };
1198 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1199 classes are not counted in the TEMPLATE_COUNT, so that in
1201 template <class T> struct S {};
1202 template <> struct S<int> { void f(); }
1203 template <> void S<int>::f();
1205 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1206 illegal; there should be no template <>.)
1208 If the function is a specialization, it is marked as such via
1209 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1210 is set up correctly, and it is added to the list of specializations
1211 for that template. */
1214 check_explicit_specialization (declarator
, decl
, template_count
, flags
)
1220 int have_def
= flags
& 2;
1221 int is_friend
= flags
& 4;
1222 int specialization
= 0;
1223 int explicit_instantiation
= 0;
1224 int member_specialization
= 0;
1226 tree ctype
= DECL_CLASS_CONTEXT (decl
);
1227 tree dname
= DECL_NAME (decl
);
1229 if (processing_specialization
)
1231 /* The last template header was of the form template <>. */
1233 if (template_header_count
> template_count
)
1235 /* There were more template headers than qualifying template
1237 if (template_header_count
- template_count
> 1)
1238 /* There shouldn't be that many template parameter lists.
1239 There can be at most one parameter list for every
1240 qualifying class, plus one for the function itself. */
1241 cp_error ("too many template parameter lists in declaration of `%D'", decl
);
1243 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1245 member_specialization
= 1;
1249 else if (template_header_count
== template_count
)
1251 /* The counts are equal. So, this might be a
1252 specialization, but it is not a specialization of a
1253 member template. It might be something like
1255 template <class T> struct S {
1259 void S<int>::f(int i) {} */
1261 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1265 /* This cannot be an explicit specialization. There are not
1266 enough headers for all of the qualifying classes. For
1267 example, we might have:
1270 void S<int>::T<char>::f();
1272 But, we're missing another template <>. */
1273 cp_error("too few template parameter lists in declaration of `%D'", decl
);
1277 else if (processing_explicit_instantiation
)
1279 if (template_header_count
)
1280 cp_error ("template parameter list used in explicit instantiation");
1283 cp_error ("definition provided for explicit instantiation");
1285 explicit_instantiation
= 1;
1287 else if (ctype
!= NULL_TREE
1288 && !TYPE_BEING_DEFINED (ctype
)
1289 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
)
1292 /* This case catches outdated code that looks like this:
1294 template <class T> struct S { void f(); };
1295 void S<int>::f() {} // Missing template <>
1297 We disable this check when the type is being defined to
1298 avoid complaining about default compiler-generated
1299 constructors, destructors, and assignment operators.
1300 Since the type is an instantiation, not a specialization,
1301 these are the only functions that can be defined before
1302 the class is complete. */
1305 template <class T> void S<int>::f() {}
1307 if (template_header_count
)
1309 cp_error ("template parameters specified in specialization");
1315 ("explicit specialization not preceded by `template <>'");
1317 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1319 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1322 /* This could be something like:
1324 template <class T> void f(T);
1325 class S { friend void f<>(int); } */
1329 /* This case handles bogus declarations like template <>
1330 template <class T> void f<int>(); */
1332 cp_error ("template-id `%D' in declaration of primary template",
1338 if (specialization
|| member_specialization
)
1340 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1341 for (; t
; t
= TREE_CHAIN (t
))
1342 if (TREE_PURPOSE (t
))
1345 ("default argument specified in explicit specialization");
1348 if (current_lang_name
== lang_name_c
)
1349 cp_error ("template specialization with C linkage");
1352 if (specialization
|| member_specialization
|| explicit_instantiation
)
1354 tree tmpl
= NULL_TREE
;
1355 tree targs
= NULL_TREE
;
1357 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1358 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
1362 my_friendly_assert (TREE_CODE (declarator
) == IDENTIFIER_NODE
,
1365 fns
= IDENTIFIER_NAMESPACE_VALUE (dname
);
1370 lookup_template_function (fns
, NULL_TREE
);
1373 if (declarator
== error_mark_node
)
1374 return error_mark_node
;
1376 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
1378 if (!explicit_instantiation
)
1379 /* A specialization in class scope. This is illegal,
1380 but the error will already have been flagged by
1381 check_specialization_scope. */
1382 return error_mark_node
;
1385 /* It's not legal to write an explicit instantiation in
1388 class C { template void f(); }
1390 This case is caught by the parser. However, on
1393 template class C { void f(); };
1395 (which is illegal) we can get here. The error will be
1402 else if (TREE_CODE (TREE_OPERAND (declarator
, 0)) == LOOKUP_EXPR
)
1404 /* A friend declaration. We can't do much, because we don't
1405 know what this resolves to, yet. */
1406 my_friendly_assert (is_friend
!= 0, 0);
1407 my_friendly_assert (!explicit_instantiation
, 0);
1408 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1411 else if (ctype
!= NULL_TREE
1412 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) ==
1415 /* Find the list of functions in ctype that have the same
1416 name as the declared function. */
1417 tree name
= TREE_OPERAND (declarator
, 0);
1418 tree fns
= NULL_TREE
;
1421 if (name
== constructor_name (ctype
)
1422 || name
== constructor_name_full (ctype
))
1424 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
1426 if (is_constructor
? !TYPE_HAS_CONSTRUCTOR (ctype
)
1427 : !TYPE_HAS_DESTRUCTOR (ctype
))
1429 /* From [temp.expl.spec]:
1431 If such an explicit specialization for the member
1432 of a class template names an implicitly-declared
1433 special member function (clause _special_), the
1434 program is ill-formed.
1436 Similar language is found in [temp.explicit]. */
1437 cp_error ("specialization of implicitly-declared special member function");
1438 return error_mark_node
;
1441 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
1444 if (!IDENTIFIER_TYPENAME_P (name
))
1446 idx
= lookup_fnfields_1 (ctype
, name
);
1448 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype
), idx
);
1454 /* For a type-conversion operator, we cannot do a
1455 name-based lookup. We might be looking for `operator
1456 int' which will be a specialization of `operator T'.
1457 So, we find *all* the conversion operators, and then
1458 select from them. */
1461 methods
= CLASSTYPE_METHOD_VEC (ctype
);
1463 for (idx
= 2; idx
< TREE_VEC_LENGTH (methods
); ++idx
)
1465 tree ovl
= TREE_VEC_ELT (methods
, idx
);
1467 if (!ovl
|| !DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
1468 /* There are no more conversion functions. */
1471 /* Glue all these conversion functions together
1472 with those we already have. */
1473 for (; ovl
; ovl
= OVL_NEXT (ovl
))
1474 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
1478 if (fns
== NULL_TREE
)
1480 cp_error ("no member function `%D' declared in `%T'",
1482 return error_mark_node
;
1485 TREE_OPERAND (declarator
, 0) = fns
;
1488 /* Figure out what exactly is being specialized at this point.
1489 Note that for an explicit instantiation, even one for a
1490 member function, we cannot tell apriori whether the
1491 instantiation is for a member template, or just a member
1492 function of a template class. Even if a member template is
1493 being instantiated, the member template arguments may be
1494 elided if they can be deduced from the rest of the
1496 tmpl
= determine_specialization (declarator
, decl
,
1498 member_specialization
);
1500 if (!tmpl
|| tmpl
== error_mark_node
)
1501 /* We couldn't figure out what this declaration was
1503 return error_mark_node
;
1506 tree gen_tmpl
= most_general_template (tmpl
);
1508 if (explicit_instantiation
)
1510 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1511 is done by do_decl_instantiation later. */
1513 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
1514 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
1516 if (arg_depth
> parm_depth
)
1518 /* If TMPL is not the most general template (for
1519 example, if TMPL is a friend template that is
1520 injected into namespace scope), then there will
1521 be too many levels fo TARGS. Remove some of them
1526 new_targs
= make_temp_vec (parm_depth
);
1527 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
1528 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
1529 = TREE_VEC_ELT (targs
, i
);
1533 decl
= instantiate_template (tmpl
, targs
);
1537 /* If we though that the DECL was a member function, but it
1538 turns out to be specializing a static member function,
1539 make DECL a static member function as well. */
1540 if (DECL_STATIC_FUNCTION_P (tmpl
)
1541 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1543 revert_static_member_fn (&decl
, 0, 0);
1544 last_function_parms
= TREE_CHAIN (last_function_parms
);
1547 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1548 DECL_TEMPLATE_INFO (decl
) = tree_cons (tmpl
, targs
, NULL_TREE
);
1550 /* Mangle the function name appropriately. Note that we do
1551 not mangle specializations of non-template member
1552 functions of template classes, e.g. with
1554 template <class T> struct S { void f(); }
1556 and given the specialization
1558 template <> void S<int>::f() {}
1560 we do not mangle S<int>::f() here. That's because it's
1561 just an ordinary member function and doesn't need special
1562 treatment. We do this here so that the ordinary,
1563 non-template, name-mangling algorith will not be used
1565 if ((is_member_template (tmpl
) || ctype
== NULL_TREE
)
1566 && name_mangling_version
>= 1)
1567 set_mangled_name_for_template_decl (decl
);
1569 if (is_friend
&& !have_def
)
1570 /* This is not really a declaration of a specialization.
1571 It's just the name of an instantiation. But, it's not
1572 a request for an instantiation, either. */
1573 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1575 /* Register this specialization so that we can find it
1577 decl
= register_specialization (decl
, gen_tmpl
, targs
);
1584 /* TYPE is being declared. Verify that the use of template headers
1585 and such is reasonable. Issue error messages if not. */
1588 maybe_check_template_type (type
)
1591 if (template_header_count
)
1593 /* We are in the scope of some `template <...>' header. */
1596 = template_class_depth_real (TYPE_CONTEXT (type
),
1597 /*count_specializations=*/1);
1599 if (template_header_count
<= context_depth
)
1600 /* This is OK; the template headers are for the context. We
1601 are actually too lenient here; like
1602 check_explicit_specialization we should consider the number
1603 of template types included in the actual declaration. For
1606 template <class T> struct S {
1607 template <class U> template <class V>
1613 template <class T> struct S {
1614 template <class U> struct I;
1617 template <class T> template <class U.
1622 else if (template_header_count
> context_depth
+ 1)
1623 /* There are two many template parameter lists. */
1624 cp_error ("too many template parameter lists in declaration of `%T'", type
);
1628 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1629 parameters. These are represented in the same format used for
1630 DECL_TEMPLATE_PARMS. */
1632 int comp_template_parms (parms1
, parms2
)
1639 if (parms1
== parms2
)
1642 for (p1
= parms1
, p2
= parms2
;
1643 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
1644 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
1646 tree t1
= TREE_VALUE (p1
);
1647 tree t2
= TREE_VALUE (p2
);
1650 my_friendly_assert (TREE_CODE (t1
) == TREE_VEC
, 0);
1651 my_friendly_assert (TREE_CODE (t2
) == TREE_VEC
, 0);
1653 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
1656 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
1658 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
1659 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
1661 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
1664 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
)
1666 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
1671 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
1672 /* One set of parameters has more parameters lists than the
1679 /* Complain if DECL shadows a template parameter.
1681 [temp.local]: A template-parameter shall not be redeclared within its
1682 scope (including nested scopes). */
1685 check_template_shadow (decl
)
1690 /* If we're not in a template, we can't possibly shadow a template
1692 if (!current_template_parms
)
1695 /* Figure out what we're shadowing. */
1696 if (TREE_CODE (decl
) == OVERLOAD
)
1697 decl
= OVL_CURRENT (decl
);
1698 olddecl
= IDENTIFIER_VALUE (DECL_NAME (decl
));
1700 /* If there's no previous binding for this name, we're not shadowing
1701 anything, let alone a template parameter. */
1705 /* If we're not shadowing a template parameter, we're done. Note
1706 that OLDDECL might be an OVERLOAD (or perhaps even an
1707 ERROR_MARK), so we can't just blithely assume it to be a _DECL
1709 if (TREE_CODE_CLASS (TREE_CODE (olddecl
)) != 'd'
1710 || !DECL_TEMPLATE_PARM_P (olddecl
))
1713 /* We check for decl != olddecl to avoid bogus errors for using a
1714 name inside a class. We check TPFI to avoid duplicate errors for
1715 inline member templates. */
1717 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
1720 cp_error_at ("declaration of `%#D'", decl
);
1721 cp_error_at (" shadows template parm `%#D'", olddecl
);
1724 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1725 ORIG_LEVEL, DECL, and TYPE. */
1728 build_template_parm_index (index
, level
, orig_level
, decl
, type
)
1735 tree t
= make_node (TEMPLATE_PARM_INDEX
);
1736 TEMPLATE_PARM_IDX (t
) = index
;
1737 TEMPLATE_PARM_LEVEL (t
) = level
;
1738 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
1739 TEMPLATE_PARM_DECL (t
) = decl
;
1740 TREE_TYPE (t
) = type
;
1745 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1746 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1747 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1748 new one is created. */
1751 reduce_template_parm_level (index
, type
, levels
)
1756 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
1757 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
1758 != TEMPLATE_PARM_LEVEL (index
) - levels
))
1761 = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index
)),
1762 DECL_NAME (TEMPLATE_PARM_DECL (index
)),
1765 = build_template_parm_index (TEMPLATE_PARM_IDX (index
),
1766 TEMPLATE_PARM_LEVEL (index
) - levels
,
1767 TEMPLATE_PARM_ORIG_LEVEL (index
),
1769 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
1771 /* Template template parameters need this. */
1772 DECL_TEMPLATE_PARMS (decl
)
1773 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
));
1776 return TEMPLATE_PARM_DESCENDANTS (index
);
1779 /* Process information from new template parameter NEXT and append it to the
1780 LIST being built. */
1783 process_template_parm (list
, next
)
1792 my_friendly_assert (TREE_CODE (parm
) == TREE_LIST
, 259);
1793 defval
= TREE_PURPOSE (parm
);
1794 parm
= TREE_VALUE (parm
);
1795 is_type
= TREE_PURPOSE (parm
) == class_type_node
;
1799 tree p
= TREE_VALUE (tree_last (list
));
1801 if (TREE_CODE (p
) == TYPE_DECL
)
1802 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
1803 else if (TREE_CODE (p
) == TEMPLATE_DECL
)
1804 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (DECL_TEMPLATE_RESULT (p
)));
1806 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
1814 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm
)) == TREE_LIST
, 260);
1815 /* is a const-param */
1816 parm
= grokdeclarator (TREE_VALUE (parm
), TREE_PURPOSE (parm
),
1817 PARM
, 0, NULL_TREE
);
1821 The top-level cv-qualifiers on the template-parameter are
1822 ignored when determining its type. */
1823 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
1825 /* A template parameter is not modifiable. */
1826 TREE_READONLY (parm
) = 1;
1827 if (IS_AGGR_TYPE (TREE_TYPE (parm
))
1828 && TREE_CODE (TREE_TYPE (parm
)) != TEMPLATE_TYPE_PARM
1829 && TREE_CODE (TREE_TYPE (parm
)) != TYPENAME_TYPE
)
1831 cp_error ("`%#T' is not a valid type for a template constant parameter",
1833 if (DECL_NAME (parm
) == NULL_TREE
)
1834 error (" a template type parameter must begin with `class' or `typename'");
1835 TREE_TYPE (parm
) = void_type_node
;
1838 && (TREE_CODE (TREE_TYPE (parm
)) == REAL_TYPE
1839 || TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
))
1840 cp_pedwarn ("`%T' is not a valid type for a template constant parameter",
1842 decl
= build_decl (CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
1843 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
1844 = build_template_parm_index (idx
, processing_template_decl
,
1845 processing_template_decl
,
1846 decl
, TREE_TYPE (parm
));
1851 parm
= TREE_VALUE (parm
);
1853 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
1855 t
= make_lang_type (TEMPLATE_TEMPLATE_PARM
);
1856 /* This is for distinguishing between real templates and template
1857 template parameters */
1858 TREE_TYPE (parm
) = t
;
1859 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
1864 t
= make_lang_type (TEMPLATE_TYPE_PARM
);
1865 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1866 decl
= build_decl (TYPE_DECL
, parm
, t
);
1869 TYPE_NAME (t
) = decl
;
1870 TYPE_STUB_DECL (t
) = decl
;
1872 TEMPLATE_TYPE_PARM_INDEX (t
)
1873 = build_template_parm_index (idx
, processing_template_decl
,
1874 processing_template_decl
,
1875 decl
, TREE_TYPE (parm
));
1877 SET_DECL_ARTIFICIAL (decl
);
1878 DECL_TEMPLATE_PARM_P (decl
) = 1;
1880 parm
= build_tree_list (defval
, parm
);
1881 return chainon (list
, parm
);
1884 /* The end of a template parameter list has been reached. Process the
1885 tree list into a parameter vector, converting each parameter into a more
1886 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1890 end_template_parm_list (parms
)
1895 tree saved_parmlist
= make_tree_vec (list_length (parms
));
1897 current_template_parms
1898 = tree_cons (build_int_2 (0, processing_template_decl
),
1899 saved_parmlist
, current_template_parms
);
1901 for (parm
= parms
, nparms
= 0;
1903 parm
= TREE_CHAIN (parm
), nparms
++)
1904 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
1906 --processing_template_parmlist
;
1908 return saved_parmlist
;
1911 /* end_template_decl is called after a template declaration is seen. */
1914 end_template_decl ()
1916 reset_specialization ();
1918 if (! processing_template_decl
)
1921 /* This matches the pushlevel in begin_template_parm_list. */
1924 --processing_template_decl
;
1925 current_template_parms
= TREE_CHAIN (current_template_parms
);
1926 (void) get_pending_sizes (); /* Why? */
1929 /* Given a template argument vector containing the template PARMS.
1930 The innermost PARMS are given first. */
1933 current_template_args ()
1936 tree args
= NULL_TREE
;
1937 int length
= TMPL_PARMS_DEPTH (current_template_parms
);
1940 /* If there is only one level of template parameters, we do not
1941 create a TREE_VEC of TREE_VECs. Instead, we return a single
1942 TREE_VEC containing the arguments. */
1944 args
= make_tree_vec (length
);
1946 for (header
= current_template_parms
; header
; header
= TREE_CHAIN (header
))
1948 tree a
= copy_node (TREE_VALUE (header
));
1951 TREE_TYPE (a
) = NULL_TREE
;
1952 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
1954 tree t
= TREE_VEC_ELT (a
, i
);
1956 /* T will be a list if we are called from within a
1957 begin/end_template_parm_list pair, but a vector directly
1958 if within a begin/end_member_template_processing pair. */
1959 if (TREE_CODE (t
) == TREE_LIST
)
1963 if (TREE_CODE (t
) == TYPE_DECL
1964 || TREE_CODE (t
) == TEMPLATE_DECL
)
1967 t
= DECL_INITIAL (t
);
1968 TREE_VEC_ELT (a
, i
) = t
;
1973 TREE_VEC_ELT (args
, --l
) = a
;
1981 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
1982 template PARMS. Used by push_template_decl below. */
1985 build_template_decl (decl
, parms
)
1989 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
1990 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
1991 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
1992 if (DECL_LANG_SPECIFIC (decl
))
1994 DECL_CLASS_CONTEXT (tmpl
) = DECL_CLASS_CONTEXT (decl
);
1995 DECL_STATIC_FUNCTION_P (tmpl
) = DECL_STATIC_FUNCTION_P (decl
);
1996 DECL_CONSTRUCTOR_P (tmpl
) = DECL_CONSTRUCTOR_P (decl
);
1997 DECL_NONCONVERTING_P (tmpl
) = DECL_NONCONVERTING_P (decl
);
2003 struct template_parm_data
2005 /* The level of the template parameters we are currently
2009 /* The index of the specialization argument we are currently
2013 /* An array whose size is the number of template parameters. The
2014 elements are non-zero if the parameter has been used in any one
2015 of the arguments processed so far. */
2018 /* An array whose size is the number of template arguments. The
2019 elements are non-zero if the argument makes use of template
2020 parameters of this level. */
2021 int* arg_uses_template_parms
;
2024 /* Subroutine of push_template_decl used to see if each template
2025 parameter in a partial specialization is used in the explicit
2026 argument list. If T is of the LEVEL given in DATA (which is
2027 treated as a template_parm_data*), then DATA->PARMS is marked
2031 mark_template_parm (t
, data
)
2037 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
2039 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
2041 level
= TEMPLATE_PARM_LEVEL (t
);
2042 idx
= TEMPLATE_PARM_IDX (t
);
2046 level
= TEMPLATE_TYPE_LEVEL (t
);
2047 idx
= TEMPLATE_TYPE_IDX (t
);
2050 if (level
== tpd
->level
)
2052 tpd
->parms
[idx
] = 1;
2053 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
2056 /* Return zero so that for_each_template_parm will continue the
2057 traversal of the tree; we want to mark *every* template parm. */
2061 /* Process the partial specialization DECL. */
2064 process_partial_specialization (decl
)
2067 tree type
= TREE_TYPE (decl
);
2068 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
2069 tree specargs
= CLASSTYPE_TI_ARGS (type
);
2070 tree inner_args
= innermost_args (specargs
);
2071 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
2072 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
2073 int nargs
= TREE_VEC_LENGTH (inner_args
);
2074 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
2076 int did_error_intro
= 0;
2077 struct template_parm_data tpd
;
2078 struct template_parm_data tpd2
;
2080 /* We check that each of the template parameters given in the
2081 partial specialization is used in the argument list to the
2082 specialization. For example:
2084 template <class T> struct S;
2085 template <class T> struct S<T*>;
2087 The second declaration is OK because `T*' uses the template
2088 parameter T, whereas
2090 template <class T> struct S<int>;
2092 is no good. Even trickier is:
2103 The S2<T> declaration is actually illegal; it is a
2104 full-specialization. Of course,
2107 struct S2<T (*)(U)>;
2109 or some such would have been OK. */
2110 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
2111 tpd
.parms
= alloca (sizeof (int) * ntparms
);
2112 bzero ((PTR
) tpd
.parms
, sizeof (int) * ntparms
);
2114 tpd
.arg_uses_template_parms
= alloca (sizeof (int) * nargs
);
2115 bzero ((PTR
) tpd
.arg_uses_template_parms
, sizeof (int) * nargs
);
2116 for (i
= 0; i
< nargs
; ++i
)
2118 tpd
.current_arg
= i
;
2119 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
2120 &mark_template_parm
,
2123 for (i
= 0; i
< ntparms
; ++i
)
2124 if (tpd
.parms
[i
] == 0)
2126 /* One of the template parms was not used in the
2128 if (!did_error_intro
)
2130 cp_error ("template parameters not used in partial specialization:");
2131 did_error_intro
= 1;
2135 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
2138 /* [temp.class.spec]
2140 The argument list of the specialization shall not be identical to
2141 the implicit argument list of the primary template. */
2142 if (comp_template_args (inner_args
,
2143 innermost_args (CLASSTYPE_TI_ARGS (TREE_TYPE
2145 cp_error ("partial specialization `%T' does not specialize any template arguments", type
);
2147 /* [temp.class.spec]
2149 A partially specialized non-type argument expression shall not
2150 involve template parameters of the partial specialization except
2151 when the argument expression is a simple identifier.
2153 The type of a template parameter corresponding to a specialized
2154 non-type argument shall not be dependent on a parameter of the
2156 my_friendly_assert (nargs
== DECL_NTPARMS (maintmpl
), 0);
2158 for (i
= 0; i
< nargs
; ++i
)
2160 tree arg
= TREE_VEC_ELT (inner_args
, i
);
2161 if (/* These first two lines are the `non-type' bit. */
2162 TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
2163 && TREE_CODE (arg
) != TEMPLATE_DECL
2164 /* This next line is the `argument expression is not just a
2165 simple identifier' condition and also the `specialized
2166 non-type argument' bit. */
2167 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
)
2169 if (tpd
.arg_uses_template_parms
[i
])
2170 cp_error ("template argument `%E' involves template parameter(s)", arg
);
2173 /* Look at the corresponding template parameter,
2174 marking which template parameters its type depends
2177 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms
,
2182 /* We haven't yet initialized TPD2. Do so now. */
2183 tpd2
.arg_uses_template_parms
2184 = (int*) alloca (sizeof (int) * nargs
);
2185 /* The number of parameters here is the number in the
2186 main template, which, as checked in the assertion
2188 tpd2
.parms
= (int*) alloca (sizeof (int) * nargs
);
2190 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
2193 /* Mark the template parameters. But this time, we're
2194 looking for the template parameters of the main
2195 template, not in the specialization. */
2196 tpd2
.current_arg
= i
;
2197 tpd2
.arg_uses_template_parms
[i
] = 0;
2198 bzero ((PTR
) tpd2
.parms
, sizeof (int) * nargs
);
2199 for_each_template_parm (type
,
2200 &mark_template_parm
,
2203 if (tpd2
.arg_uses_template_parms
[i
])
2205 /* The type depended on some template parameters.
2206 If they are fully specialized in the
2207 specialization, that's OK. */
2209 for (j
= 0; j
< nargs
; ++j
)
2210 if (tpd2
.parms
[j
] != 0
2211 && tpd
.arg_uses_template_parms
[j
])
2213 cp_error ("type `%T' of template argument `%E' depends on template parameter(s)",
2223 if (retrieve_specialization (maintmpl
, specargs
))
2224 /* We've already got this specialization. */
2227 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
) = CLASSTYPE_TI_SPEC_INFO (type
)
2228 = tree_cons (inner_args
, inner_parms
,
2229 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
2230 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
2234 /* Check that a template declaration's use of default arguments is not
2235 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2236 non-zero if DECL is the thing declared by a primary template.
2237 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2240 check_default_tmpl_args (decl
, parms
, is_primary
, is_partial
)
2247 int last_level_to_check
;
2252 A default template-argument shall not be specified in a
2253 function template declaration or a function template definition, nor
2254 in the template-parameter-list of the definition of a member of a
2257 if (TREE_CODE (DECL_REAL_CONTEXT (decl
)) == FUNCTION_DECL
)
2258 /* You can't have a function template declaration in a local
2259 scope, nor you can you define a member of a class template in a
2263 if (current_class_type
2264 && !TYPE_BEING_DEFINED (current_class_type
)
2265 && DECL_LANG_SPECIFIC (decl
)
2266 /* If this is either a friend defined in the scope of the class
2267 or a member function. */
2268 && DECL_CLASS_CONTEXT (decl
) == current_class_type
2269 /* And, if it was a member function, it really was defined in
2270 the scope of the class. */
2271 && (!DECL_FUNCTION_MEMBER_P (decl
) || DECL_DEFINED_IN_CLASS_P (decl
)))
2272 /* We already checked these parameters when the template was
2273 declared, so there's no need to do it again now. This function
2274 was defined in class scope, but we're processing it's body now
2275 that the class is complete. */
2280 If a template-parameter has a default template-argument, all
2281 subsequent template-parameters shall have a default
2282 template-argument supplied. */
2283 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
2285 tree inner_parms
= TREE_VALUE (parm_level
);
2286 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
2287 int seen_def_arg_p
= 0;
2290 for (i
= 0; i
< ntparms
; ++i
)
2292 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
2293 if (TREE_PURPOSE (parm
))
2295 else if (seen_def_arg_p
)
2297 cp_error ("no default argument for `%D'", TREE_VALUE (parm
));
2298 /* For better subsequent error-recovery, we indicate that
2299 there should have been a default argument. */
2300 TREE_PURPOSE (parm
) = error_mark_node
;
2305 if (TREE_CODE (decl
) != TYPE_DECL
|| is_partial
|| !is_primary
)
2306 /* For an ordinary class template, default template arguments are
2307 allowed at the innermost level, e.g.:
2308 template <class T = int>
2310 but, in a partial specialization, they're not allowed even
2311 there, as we have in [temp.class.spec]:
2313 The template parameter list of a specialization shall not
2314 contain default template argument values.
2316 So, for a partial specialization, or for a function template,
2317 we look at all of them. */
2320 /* But, for a primary class template that is not a partial
2321 specialization we look at all template parameters except the
2323 parms
= TREE_CHAIN (parms
);
2325 /* Figure out what error message to issue. */
2326 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2327 msg
= "default argument for template parameter in function template `%D'";
2328 else if (is_partial
)
2329 msg
= "default argument in partial specialization `%D'";
2331 msg
= "default argument for template parameter for class enclosing `%D'";
2333 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
2334 /* If we're inside a class definition, there's no need to
2335 examine the parameters to the class itself. On the one
2336 hand, they will be checked when the class is defined, and,
2337 on the other, default arguments are legal in things like:
2338 template <class T = double>
2339 struct S { template <class U> void f(U); };
2340 Here the default argument for `S' has no bearing on the
2341 declaration of `f'. */
2342 last_level_to_check
= template_class_depth (current_class_type
) + 1;
2344 /* Check everything. */
2345 last_level_to_check
= 0;
2347 for (parm_level
= parms
;
2348 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
2349 parm_level
= TREE_CHAIN (parm_level
))
2351 tree inner_parms
= TREE_VALUE (parm_level
);
2355 ntparms
= TREE_VEC_LENGTH (inner_parms
);
2356 for (i
= 0; i
< ntparms
; ++i
)
2357 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
2361 cp_error (msg
, decl
);
2365 /* Clear out the default argument so that we are not
2367 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
2370 /* At this point, if we're still interested in issuing messages,
2371 they must apply to classes surrounding the object declared. */
2373 msg
= "default argument for template parameter for class enclosing `%D'";
2377 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2378 parameters given by current_template_args, or reuses a
2379 previously existing one, if appropriate. Returns the DECL, or an
2380 equivalent one, if it is replaced via a call to duplicate_decls.
2382 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2385 push_template_decl_real (decl
, is_friend
)
2395 int new_template_p
= 0;
2397 /* See if this is a partial specialization. */
2398 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
2399 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
2400 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
2402 is_friend
|= (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
));
2405 /* For a friend, we want the context of the friend function, not
2406 the type of which it is a friend. */
2407 ctx
= DECL_CONTEXT (decl
);
2408 else if (DECL_REAL_CONTEXT (decl
)
2409 && TREE_CODE (DECL_REAL_CONTEXT (decl
)) != NAMESPACE_DECL
)
2410 /* In the case of a virtual function, we want the class in which
2412 ctx
= DECL_REAL_CONTEXT (decl
);
2414 /* Otherwise, if we're currently definining some class, the DECL
2415 is assumed to be a member of the class. */
2416 ctx
= current_scope ();
2418 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
2421 if (!DECL_CONTEXT (decl
))
2422 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
2424 /* See if this is a primary template. */
2425 primary
= pseudo_global_level_p ();
2429 if (current_lang_name
== lang_name_c
)
2430 cp_error ("template with C linkage");
2431 else if (TREE_CODE (decl
) == TYPE_DECL
2432 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
2433 cp_error ("template class without a name");
2434 else if ((DECL_IMPLICIT_TYPEDEF_P (decl
)
2435 && CLASS_TYPE_P (TREE_TYPE (decl
)))
2436 || (TREE_CODE (decl
) == VAR_DECL
&& ctx
&& CLASS_TYPE_P (ctx
))
2437 || TREE_CODE (decl
) == FUNCTION_DECL
)
2440 cp_error ("template declaration of `%#D'", decl
);
2443 /* Check to see that the rules regarding the use of default
2444 arguments are not being violated. */
2445 check_default_tmpl_args (decl
, current_template_parms
,
2446 primary
, is_partial
);
2449 return process_partial_specialization (decl
);
2451 args
= current_template_args ();
2454 || TREE_CODE (ctx
) == FUNCTION_DECL
2455 || TYPE_BEING_DEFINED (ctx
)
2456 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
2458 if (DECL_LANG_SPECIFIC (decl
)
2459 && DECL_TEMPLATE_INFO (decl
)
2460 && DECL_TI_TEMPLATE (decl
))
2461 tmpl
= DECL_TI_TEMPLATE (decl
);
2462 /* If DECL is a TYPE_DECL for a class-template, then there won't
2463 be DECL_LANG_SPECIFIC. The information equivalent to
2464 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2465 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
2466 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
2467 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
2469 /* Since a template declaration already existed for this
2470 class-type, we must be redeclaring it here. Make sure
2471 that the redeclaration is legal. */
2472 redeclare_class_template (TREE_TYPE (decl
),
2473 current_template_parms
);
2474 /* We don't need to create a new TEMPLATE_DECL; just use the
2475 one we already had. */
2476 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
2480 tmpl
= build_template_decl (decl
, current_template_parms
);
2483 if (DECL_LANG_SPECIFIC (decl
)
2484 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2486 /* A specialization of a member template of a template
2488 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2489 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
2490 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
2496 tree a
, t
, current
, parms
;
2499 if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx
))
2500 cp_error ("must specialize `%#T' before defining member `%#D'",
2502 if (TREE_CODE (decl
) == TYPE_DECL
)
2504 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl
)))
2505 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2506 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
2507 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
2508 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
2511 cp_error ("`%D' does not declare a template type", decl
);
2515 else if (! DECL_TEMPLATE_INFO (decl
))
2517 cp_error ("template definition of non-template `%#D'", decl
);
2521 tmpl
= DECL_TI_TEMPLATE (decl
);
2523 if (is_member_template (tmpl
)
2524 && DECL_FUNCTION_TEMPLATE_P (tmpl
)
2525 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
2526 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2530 /* The declaration is a specialization of a member
2531 template, declared outside the class. Therefore, the
2532 innermost template arguments will be NULL, so we
2533 replace them with the arguments determined by the
2534 earlier call to check_explicit_specialization. */
2535 args
= DECL_TI_ARGS (decl
);
2538 = build_template_decl (decl
, current_template_parms
);
2539 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
2540 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
2541 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
2542 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
2543 DECL_TEMPLATE_INFO (new_tmpl
)
2544 = tree_cons (tmpl
, args
, NULL_TREE
);
2546 register_specialization (new_tmpl
, tmpl
, args
);
2550 /* Make sure the template headers we got make sense. */
2552 parms
= DECL_TEMPLATE_PARMS (tmpl
);
2553 i
= TMPL_PARMS_DEPTH (parms
);
2554 if (TMPL_ARGS_DEPTH (args
) != i
)
2556 cp_error ("expected %d levels of template parms for `%#D', got %d",
2557 i
, decl
, TMPL_ARGS_DEPTH (args
));
2560 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
2562 a
= TMPL_ARGS_LEVEL (args
, i
);
2563 t
= INNERMOST_TEMPLATE_PARMS (parms
);
2565 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
2567 if (current
== decl
)
2568 cp_error ("got %d template parameters for `%#D'",
2569 TREE_VEC_LENGTH (a
), decl
);
2571 cp_error ("got %d template parameters for `%#T'",
2572 TREE_VEC_LENGTH (a
), current
);
2573 cp_error (" but %d required", TREE_VEC_LENGTH (t
));
2576 /* Perhaps we should also check that the parms are used in the
2577 appropriate qualifying scopes in the declarator? */
2579 if (current
== decl
)
2582 current
= TYPE_CONTEXT (current
);
2586 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2587 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
2589 /* Push template declarations for global functions and types. Note
2590 that we do not try to push a global template friend declared in a
2591 template class; such a thing may well depend on the template
2592 parameters of the class. */
2593 if (new_template_p
&& !ctx
2594 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
2595 tmpl
= pushdecl_namespace_level (tmpl
);
2598 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
2600 info
= tree_cons (tmpl
, args
, NULL_TREE
);
2602 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
2604 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
2605 if ((!ctx
|| TREE_CODE (ctx
) != FUNCTION_DECL
)
2606 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
)
2607 DECL_NAME (decl
) = classtype_mangled_name (TREE_TYPE (decl
));
2609 else if (DECL_LANG_SPECIFIC (decl
))
2610 DECL_TEMPLATE_INFO (decl
) = info
;
2612 return DECL_TEMPLATE_RESULT (tmpl
);
2616 push_template_decl (decl
)
2619 return push_template_decl_real (decl
, 0);
2622 /* Called when a class template TYPE is redeclared with the indicated
2623 template PARMS, e.g.:
2625 template <class T> struct S;
2626 template <class T> struct S {}; */
2629 redeclare_class_template (type
, parms
)
2637 if (!TYPE_TEMPLATE_INFO (type
))
2639 cp_error ("`%T' is not a template type", type
);
2643 tmpl
= TYPE_TI_TEMPLATE (type
);
2644 if (!PRIMARY_TEMPLATE_P (tmpl
))
2645 /* The type is nested in some template class. Nothing to worry
2646 about here; there are no new template parameters for the nested
2650 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
2651 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
2653 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
2655 cp_error_at ("previous declaration `%D'", tmpl
);
2656 cp_error ("used %d template parameter%s instead of %d",
2657 TREE_VEC_LENGTH (tmpl_parms
),
2658 TREE_VEC_LENGTH (tmpl_parms
) == 1 ? "" : "s",
2659 TREE_VEC_LENGTH (parms
));
2663 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
2665 tree tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
2666 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
2667 tree tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
2668 tree parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
2670 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
))
2672 cp_error_at ("template parameter `%#D'", tmpl_parm
);
2673 cp_error ("redeclared here as `%#D'", parm
);
2677 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
2679 /* We have in [temp.param]:
2681 A template-parameter may not be given default arguments
2682 by two different declarations in the same scope. */
2683 cp_error ("redefinition of default argument for `%#D'", parm
);
2684 cp_error_at (" original definition appeared here", tmpl_parm
);
2688 if (parm_default
!= NULL_TREE
)
2689 /* Update the previous template parameters (which are the ones
2690 that will really count) with the new default value. */
2691 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
2692 else if (tmpl_default
!= NULL_TREE
)
2693 /* Update the new parameters, too; they'll be used as the
2694 parameters for any members. */
2695 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
2699 /* Attempt to convert the non-type template parameter EXPR to the
2700 indicated TYPE. If the conversion is successful, return the
2701 converted value. If the conversion is unsuccesful, return
2702 NULL_TREE if we issued an error message, or error_mark_node if we
2703 did not. We issue error messages for out-and-out bad template
2704 parameters, but not simply because the conversion failed, since we
2705 might be just trying to do argument deduction. By the time this
2706 function is called, neither TYPE nor EXPR may make use of template
2710 convert_nontype_argument (type
, expr
)
2714 tree expr_type
= TREE_TYPE (expr
);
2716 /* A template-argument for a non-type, non-template
2717 template-parameter shall be one of:
2719 --an integral constant-expression of integral or enumeration
2722 --the name of a non-type template-parameter; or
2724 --the name of an object or function with external linkage,
2725 including function templates and function template-ids but
2726 excluding non-static class members, expressed as id-expression;
2729 --the address of an object or function with external linkage,
2730 including function templates and function template-ids but
2731 excluding non-static class members, expressed as & id-expression
2732 where the & is optional if the name refers to a function or
2735 --a pointer to member expressed as described in _expr.unary.op_. */
2737 /* An integral constant-expression can include const variables or
2738 enumerators. Simplify things by folding them to their values,
2739 unless we're about to bind the declaration to a reference
2741 if (INTEGRAL_TYPE_P (expr_type
) && TREE_READONLY_DECL_P (expr
)
2742 && TREE_CODE (type
) != REFERENCE_TYPE
)
2743 expr
= decl_constant_value (expr
);
2745 if (is_overloaded_fn (expr
))
2746 /* OK for now. We'll check that it has external linkage later.
2747 Check this first since if expr_type is the unknown_type_node
2748 we would otherwise complain below. */
2750 else if (TYPE_PTRMEM_P (expr_type
)
2751 || TYPE_PTRMEMFUNC_P (expr_type
))
2753 if (TREE_CODE (expr
) != PTRMEM_CST
)
2756 else if (TYPE_PTR_P (expr_type
)
2757 || TYPE_PTRMEM_P (expr_type
)
2758 || TREE_CODE (expr_type
) == ARRAY_TYPE
2759 || TREE_CODE (type
) == REFERENCE_TYPE
2760 /* If expr is the address of an overloaded function, we
2761 will get the unknown_type_node at this point. */
2762 || expr_type
== unknown_type_node
)
2768 if (TREE_CODE (type
) == REFERENCE_TYPE
2769 || TREE_CODE (expr_type
) == ARRAY_TYPE
)
2773 if (TREE_CODE (e
) != ADDR_EXPR
)
2776 cp_error ("`%E' is not a valid template argument", expr
);
2777 if (TYPE_PTR_P (expr_type
))
2779 if (TREE_CODE (TREE_TYPE (expr_type
)) == FUNCTION_TYPE
)
2780 cp_error ("it must be the address of a function with external linkage");
2782 cp_error ("it must be the address of an object with external linkage");
2784 else if (TYPE_PTRMEM_P (expr_type
)
2785 || TYPE_PTRMEMFUNC_P (expr_type
))
2786 cp_error ("it must be a pointer-to-member of the form `&X::Y'");
2791 referent
= TREE_OPERAND (e
, 0);
2792 STRIP_NOPS (referent
);
2795 if (TREE_CODE (referent
) == STRING_CST
)
2797 cp_error ("string literal %E is not a valid template argument",
2799 error ("because it is the address of an object with static linkage");
2803 if (is_overloaded_fn (referent
))
2804 /* We'll check that it has external linkage later. */
2806 else if (TREE_CODE (referent
) != VAR_DECL
)
2808 else if (!TREE_PUBLIC (referent
))
2810 cp_error ("address of non-extern `%E' cannot be used as template argument", referent
);
2811 return error_mark_node
;
2814 else if (INTEGRAL_TYPE_P (expr_type
)
2815 || TYPE_PTRMEM_P (expr_type
)
2816 || TYPE_PTRMEMFUNC_P (expr_type
)
2817 /* The next two are g++ extensions. */
2818 || TREE_CODE (expr_type
) == REAL_TYPE
2819 || TREE_CODE (expr_type
) == COMPLEX_TYPE
)
2821 if (! TREE_CONSTANT (expr
))
2824 cp_error ("non-constant `%E' cannot be used as template argument",
2831 cp_error ("object `%E' cannot be used as template argument", expr
);
2835 switch (TREE_CODE (type
))
2840 /* For a non-type template-parameter of integral or enumeration
2841 type, integral promotions (_conv.prom_) and integral
2842 conversions (_conv.integral_) are applied. */
2843 if (!INTEGRAL_TYPE_P (expr_type
))
2844 return error_mark_node
;
2846 /* It's safe to call digest_init in this case; we know we're
2847 just converting one integral constant expression to another. */
2848 expr
= digest_init (type
, expr
, (tree
*) 0);
2850 if (TREE_CODE (expr
) != INTEGER_CST
)
2851 /* Curiously, some TREE_CONSTANT integral expressions do not
2852 simplify to integer constants. For example, `3 % 0',
2853 remains a TRUNC_MOD_EXPR. */
2860 /* These are g++ extensions. */
2861 if (TREE_CODE (expr_type
) != TREE_CODE (type
))
2862 return error_mark_node
;
2864 expr
= digest_init (type
, expr
, (tree
*) 0);
2866 if (TREE_CODE (expr
) != REAL_CST
)
2873 tree type_pointed_to
= TREE_TYPE (type
);
2875 if (TYPE_PTRMEM_P (type
))
2879 /* For a non-type template-parameter of type pointer to data
2880 member, qualification conversions (_conv.qual_) are
2882 e
= perform_qualification_conversions (type
, expr
);
2883 if (TREE_CODE (e
) == NOP_EXPR
)
2884 /* The call to perform_qualification_conversions will
2885 insert a NOP_EXPR over EXPR to do express conversion,
2886 if necessary. But, that will confuse us if we use
2887 this (converted) template parameter to instantiate
2888 another template; then the thing will not look like a
2889 valid template argument. So, just make a new
2890 constant, of the appropriate type. */
2891 e
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
2894 else if (TREE_CODE (type_pointed_to
) == FUNCTION_TYPE
)
2896 /* For a non-type template-parameter of type pointer to
2897 function, only the function-to-pointer conversion
2898 (_conv.func_) is applied. If the template-argument
2899 represents a set of overloaded functions (or a pointer to
2900 such), the matching function is selected from the set
2905 if (TREE_CODE (expr
) == ADDR_EXPR
)
2906 fns
= TREE_OPERAND (expr
, 0);
2910 fn
= instantiate_type (type_pointed_to
, fns
, 0);
2912 if (fn
== error_mark_node
)
2913 return error_mark_node
;
2915 if (!TREE_PUBLIC (fn
))
2917 if (really_overloaded_fn (fns
))
2918 return error_mark_node
;
2923 expr
= build_unary_op (ADDR_EXPR
, fn
, 0);
2925 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2931 /* For a non-type template-parameter of type pointer to
2932 object, qualification conversions (_conv.qual_) and the
2933 array-to-pointer conversion (_conv.array_) are applied.
2934 [Note: In particular, neither the null pointer conversion
2935 (_conv.ptr_) nor the derived-to-base conversion
2936 (_conv.ptr_) are applied. Although 0 is a valid
2937 template-argument for a non-type template-parameter of
2938 integral type, it is not a valid template-argument for a
2939 non-type template-parameter of pointer type.]
2941 The call to decay_conversion performs the
2942 array-to-pointer conversion, if appropriate. */
2943 expr
= decay_conversion (expr
);
2945 if (expr
== error_mark_node
)
2946 return error_mark_node
;
2948 return perform_qualification_conversions (type
, expr
);
2953 case REFERENCE_TYPE
:
2955 tree type_referred_to
= TREE_TYPE (type
);
2957 if (TREE_CODE (type_referred_to
) == FUNCTION_TYPE
)
2959 /* For a non-type template-parameter of type reference to
2960 function, no conversions apply. If the
2961 template-argument represents a set of overloaded
2962 functions, the matching function is selected from the
2963 set (_over.over_). */
2967 fn
= instantiate_type (type_referred_to
, fns
, 0);
2969 if (fn
== error_mark_node
)
2970 return error_mark_node
;
2972 if (!TREE_PUBLIC (fn
))
2974 if (really_overloaded_fn (fns
))
2975 /* Don't issue an error here; we might get a different
2976 function if the overloading had worked out
2978 return error_mark_node
;
2983 my_friendly_assert (same_type_p (type_referred_to
,
2991 /* For a non-type template-parameter of type reference to
2992 object, no conversions apply. The type referred to by the
2993 reference may be more cv-qualified than the (otherwise
2994 identical) type of the template-argument. The
2995 template-parameter is bound directly to the
2996 template-argument, which must be an lvalue. */
2997 if ((TYPE_MAIN_VARIANT (expr_type
)
2998 != TYPE_MAIN_VARIANT (type_referred_to
))
2999 || !at_least_as_qualified_p (type_referred_to
,
3001 || !real_lvalue_p (expr
))
3002 return error_mark_node
;
3011 if (!TYPE_PTRMEMFUNC_P (type
))
3012 /* This handles templates like
3013 template<class T, T t> void f();
3014 when T is substituted with any class. The second template
3015 parameter becomes invalid and the template candidate is
3017 return error_mark_node
;
3019 /* For a non-type template-parameter of type pointer to member
3020 function, no conversions apply. If the template-argument
3021 represents a set of overloaded member functions, the
3022 matching member function is selected from the set
3025 if (!TYPE_PTRMEMFUNC_P (expr_type
) &&
3026 expr_type
!= unknown_type_node
)
3027 return error_mark_node
;
3029 if (TREE_CODE (expr
) == PTRMEM_CST
)
3031 /* A ptr-to-member constant. */
3032 if (!same_type_p (type
, expr_type
))
3033 return error_mark_node
;
3038 if (TREE_CODE (expr
) != ADDR_EXPR
)
3039 return error_mark_node
;
3041 expr
= instantiate_type (type
, expr
, 0);
3043 if (expr
== error_mark_node
)
3044 return error_mark_node
;
3046 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
3053 /* All non-type parameters must have one of these types. */
3054 my_friendly_abort (0);
3058 return error_mark_node
;
3061 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3062 template template parameters. Both PARM_PARMS and ARG_PARMS are
3063 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3066 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3067 the case, then extra parameters must have default arguments.
3069 Consider the example:
3070 template <class T, class Allocator = allocator> class vector;
3071 template<template <class U> class TT> class C;
3073 C<vector> is a valid instantiation. PARM_PARMS for the above code
3074 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3075 T and Allocator) and OUTER_ARGS contains the argument that is used to
3076 substitute the TT parameter. */
3079 coerce_template_template_parms (parm_parms
, arg_parms
, complain
,
3080 in_decl
, outer_args
)
3081 tree parm_parms
, arg_parms
;
3083 tree in_decl
, outer_args
;
3085 int nparms
, nargs
, i
;
3088 my_friendly_assert (TREE_CODE (parm_parms
) == TREE_VEC
, 0);
3089 my_friendly_assert (TREE_CODE (arg_parms
) == TREE_VEC
, 0);
3091 nparms
= TREE_VEC_LENGTH (parm_parms
);
3092 nargs
= TREE_VEC_LENGTH (arg_parms
);
3094 /* The rule here is opposite of coerce_template_parms. */
3097 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms
, nparms
)) == NULL_TREE
))
3100 for (i
= 0; i
< nparms
; ++i
)
3102 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
3103 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
3105 if (arg
== NULL_TREE
|| arg
== error_mark_node
3106 || parm
== NULL_TREE
|| parm
== error_mark_node
)
3109 if (TREE_CODE (arg
) != TREE_CODE (parm
))
3112 switch (TREE_CODE (parm
))
3118 /* We encounter instantiations of templates like
3119 template <template <template <class> class> class TT>
3122 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
3123 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
3125 if (!coerce_template_template_parms (parmparm
, argparm
,
3133 /* The tsubst call is used to handle cases such as
3134 template <class T, template <T> class TT> class D;
3135 i.e. the parameter list of TT depends on earlier parameters. */
3136 if (!same_type_p (tsubst (TREE_TYPE (parm
), outer_args
,
3143 my_friendly_abort (0);
3149 /* Convert the indicated template ARG as necessary to match the
3150 indicated template PARM. Returns the converted ARG, or
3151 error_mark_node if the conversion was unsuccessful. Error messages
3152 are issued if COMPLAIN is non-zero. This conversion is for the Ith
3153 parameter in the parameter list. ARGS is the full set of template
3154 arguments deduced so far. */
3157 convert_template_argument (parm
, arg
, args
, complain
, i
, in_decl
)
3167 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
3169 inner_args
= innermost_args (args
);
3171 if (TREE_CODE (arg
) == TREE_LIST
3172 && TREE_TYPE (arg
) != NULL_TREE
3173 && TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
3175 /* The template argument was the name of some
3176 member function. That's usually
3177 illegal, but static members are OK. In any
3178 case, grab the underlying fields/functions
3179 and issue an error later if required. */
3180 arg
= TREE_VALUE (arg
);
3181 TREE_TYPE (arg
) = unknown_type_node
;
3184 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
3185 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
3186 || requires_tmpl_type
);
3188 /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true,
3189 we also accept implicitly created TYPE_DECL as a valid argument.
3190 This is necessary to handle the case where we pass a template name
3191 to a template template parameter in a scope where we've derived from
3192 in instantiation of that template, so the template name refers to that
3193 instantiation. We really ought to handle this better. */
3195 = ((TREE_CODE (arg
) == TEMPLATE_DECL
3196 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
3197 || (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
3198 && !TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (arg
))
3199 || (TREE_CODE (arg
) == RECORD_TYPE
3200 && CLASSTYPE_TEMPLATE_INFO (arg
)
3201 && TREE_CODE (TYPE_NAME (arg
)) == TYPE_DECL
3202 && DECL_ARTIFICIAL (TYPE_NAME (arg
))
3203 && requires_tmpl_type
3204 && is_base_of_enclosing_class (arg
, current_class_type
)));
3205 if (is_tmpl_type
&& TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
3206 arg
= TYPE_STUB_DECL (arg
);
3207 else if (is_tmpl_type
&& TREE_CODE (arg
) == RECORD_TYPE
)
3208 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
3210 is_type
= TREE_CODE_CLASS (TREE_CODE (arg
)) == 't' || is_tmpl_type
;
3212 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
3213 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
3215 cp_pedwarn ("to refer to a type member of a template parameter,");
3216 cp_pedwarn (" use `typename %E'", arg
);
3218 arg
= make_typename_type (TREE_OPERAND (arg
, 0),
3219 TREE_OPERAND (arg
, 1));
3222 if (is_type
!= requires_type
)
3228 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3231 cp_error (" expected a constant of type `%T', got `%T'",
3233 (is_tmpl_type
? DECL_NAME (arg
) : arg
));
3235 cp_error (" expected a type, got `%E'", arg
);
3238 return error_mark_node
;
3240 if (is_tmpl_type
^ requires_tmpl_type
)
3242 if (in_decl
&& complain
)
3244 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3247 cp_error (" expected a type, got `%T'", DECL_NAME (arg
));
3249 cp_error (" expected a class template, got `%T'", arg
);
3251 return error_mark_node
;
3256 if (requires_tmpl_type
)
3258 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
3259 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
3261 if (coerce_template_template_parms (parmparm
, argparm
, complain
,
3262 in_decl
, inner_args
))
3266 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3268 if (val
!= error_mark_node
3269 && DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
3270 val
= TREE_TYPE (val
);
3274 if (in_decl
&& complain
)
3276 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3278 cp_error (" expected a template of type `%D', got `%D'", parm
, arg
);
3281 val
= error_mark_node
;
3286 val
= groktypename (arg
);
3287 if (! processing_template_decl
)
3289 /* [basic.link]: A name with no linkage (notably, the
3290 name of a class or enumeration declared in a local
3291 scope) shall not be used to declare an entity with
3292 linkage. This implies that names with no linkage
3293 cannot be used as template arguments. */
3294 tree t
= no_linkage_check (val
);
3297 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
3299 ("template-argument `%T' uses anonymous type", val
);
3302 ("template-argument `%T' uses local type `%T'",
3304 return error_mark_node
;
3311 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
3313 if (processing_template_decl
)
3314 arg
= maybe_fold_nontype_arg (arg
);
3316 if (!uses_template_parms (arg
) && !uses_template_parms (t
))
3317 /* We used to call digest_init here. However, digest_init
3318 will report errors, which we don't want when complain
3319 is zero. More importantly, digest_init will try too
3320 hard to convert things: for example, `0' should not be
3321 converted to pointer type at this point according to
3322 the standard. Accepting this is not merely an
3323 extension, since deciding whether or not these
3324 conversions can occur is part of determining which
3325 function template to call, or whether a given epxlicit
3326 argument specification is legal. */
3327 val
= convert_nontype_argument (t
, arg
);
3331 if (val
== NULL_TREE
)
3332 val
= error_mark_node
;
3333 else if (val
== error_mark_node
&& complain
)
3334 cp_error ("could not convert template argument `%E' to `%T'",
3341 /* Convert all template arguments to their appropriate types, and
3342 return a vector containing the innermost resulting template
3343 arguments. If any error occurs, return error_mark_node, and, if
3344 COMPLAIN is non-zero, issue an error message. Some error messages
3345 are issued even if COMPLAIN is zero; for instance, if a template
3346 argument is composed from a local class.
3348 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3349 provided in ARGLIST, or else trailing parameters must have default
3350 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3351 deduction for any unspecified trailing arguments.
3353 The resulting TREE_VEC is allocated on a temporary obstack, and
3354 must be explicitly copied if it will be permanent. */
3357 coerce_template_parms (parms
, args
, in_decl
,
3359 require_all_arguments
)
3363 int require_all_arguments
;
3365 int nparms
, nargs
, i
, lost
= 0;
3368 tree new_inner_args
;
3370 inner_args
= innermost_args (args
);
3371 nargs
= NUM_TMPL_ARGS (inner_args
);
3372 nparms
= TREE_VEC_LENGTH (parms
);
3376 && require_all_arguments
3377 && TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
)) == NULL_TREE
))
3381 cp_error ("wrong number of template arguments (%d, should be %d)",
3385 cp_error_at ("provided for `%D'", in_decl
);
3388 return error_mark_node
;
3391 new_inner_args
= make_temp_vec (nparms
);
3392 new_args
= add_outermost_template_args (args
, new_inner_args
);
3393 for (i
= 0; i
< nparms
; i
++)
3398 /* Get the Ith template parameter. */
3399 parm
= TREE_VEC_ELT (parms
, i
);
3401 /* Calculate the Ith argument. */
3402 if (inner_args
&& TREE_CODE (inner_args
) == TREE_LIST
)
3404 arg
= TREE_VALUE (inner_args
);
3405 inner_args
= TREE_CHAIN (inner_args
);
3408 arg
= TREE_VEC_ELT (inner_args
, i
);
3409 /* If no template argument was supplied, look for a default
3411 else if (TREE_PURPOSE (parm
) == NULL_TREE
)
3413 /* There was no default value. */
3414 my_friendly_assert (!require_all_arguments
, 0);
3417 else if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
)
3418 arg
= tsubst (TREE_PURPOSE (parm
), new_args
, complain
, in_decl
);
3420 arg
= tsubst_expr (TREE_PURPOSE (parm
), new_args
, complain
,
3423 /* Now, convert the Ith argument, as necessary. */
3424 if (arg
== NULL_TREE
)
3425 /* We're out of arguments. */
3427 my_friendly_assert (!require_all_arguments
, 0);
3430 else if (arg
== error_mark_node
)
3432 cp_error ("template argument %d is invalid", i
+ 1);
3433 arg
= error_mark_node
;
3436 arg
= convert_template_argument (TREE_VALUE (parm
),
3437 arg
, new_args
, complain
, i
,
3440 if (arg
== error_mark_node
)
3442 TREE_VEC_ELT (new_inner_args
, i
) = arg
;
3446 return error_mark_node
;
3448 return new_inner_args
;
3451 /* Returns 1 if template args OT and NT are equivalent. */
3454 template_args_equal (ot
, nt
)
3459 if (TREE_CODE (nt
) != TREE_CODE (ot
))
3461 if (TREE_CODE (nt
) == TREE_VEC
)
3462 /* For member templates */
3463 return comp_template_args (ot
, nt
);
3464 else if (TREE_CODE_CLASS (TREE_CODE (ot
)) == 't')
3465 return same_type_p (ot
, nt
);
3467 return (cp_tree_equal (ot
, nt
) > 0);
3470 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3471 of template arguments. Returns 0 otherwise. */
3474 comp_template_args (oldargs
, newargs
)
3475 tree oldargs
, newargs
;
3479 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
3482 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
3484 tree nt
= TREE_VEC_ELT (newargs
, i
);
3485 tree ot
= TREE_VEC_ELT (oldargs
, i
);
3487 if (! template_args_equal (ot
, nt
))
3493 /* Given class template name and parameter list, produce a user-friendly name
3494 for the instantiation. */
3497 mangle_class_name_for_template (name
, parms
, arglist
)
3499 tree parms
, arglist
;
3501 static struct obstack scratch_obstack
;
3502 static char *scratch_firstobj
;
3505 if (!scratch_firstobj
)
3506 gcc_obstack_init (&scratch_obstack
);
3508 obstack_free (&scratch_obstack
, scratch_firstobj
);
3509 scratch_firstobj
= obstack_alloc (&scratch_obstack
, 1);
3511 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
3512 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
3516 nparms
= TREE_VEC_LENGTH (parms
);
3517 arglist
= innermost_args (arglist
);
3518 my_friendly_assert (nparms
== TREE_VEC_LENGTH (arglist
), 268);
3519 for (i
= 0; i
< nparms
; i
++)
3521 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
3522 tree arg
= TREE_VEC_ELT (arglist
, i
);
3527 if (TREE_CODE (parm
) == TYPE_DECL
)
3529 cat (type_as_string (arg
, TS_CHASE_TYPEDEFS
));
3532 else if (TREE_CODE (parm
) == TEMPLATE_DECL
)
3534 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
3536 /* Already substituted with real template. Just output
3537 the template name here */
3538 tree context
= DECL_CONTEXT (arg
);
3541 /* The template may be defined in a namespace, or
3542 may be a member template. */
3543 my_friendly_assert (TREE_CODE (context
) == NAMESPACE_DECL
3544 || CLASS_TYPE_P (context
),
3546 cat(decl_as_string (DECL_CONTEXT (arg
), 0));
3549 cat (IDENTIFIER_POINTER (DECL_NAME (arg
)));
3552 /* Output the parameter declaration */
3553 cat (type_as_string (arg
, TS_CHASE_TYPEDEFS
));
3557 my_friendly_assert (TREE_CODE (parm
) == PARM_DECL
, 269);
3559 if (TREE_CODE (arg
) == TREE_LIST
)
3561 /* New list cell was built because old chain link was in
3563 my_friendly_assert (TREE_PURPOSE (arg
) == NULL_TREE
, 270);
3564 arg
= TREE_VALUE (arg
);
3566 /* No need to check arglist against parmlist here; we did that
3567 in coerce_template_parms, called from lookup_template_class. */
3568 cat (expr_as_string (arg
, 0));
3571 char *bufp
= obstack_next_free (&scratch_obstack
);
3573 while (bufp
[offset
- 1] == ' ')
3575 obstack_blank_fast (&scratch_obstack
, offset
);
3577 /* B<C<char> >, not B<C<char>> */
3578 if (bufp
[offset
- 1] == '>')
3583 return (char *) obstack_base (&scratch_obstack
);
3587 classtype_mangled_name (t
)
3590 if (CLASSTYPE_TEMPLATE_INFO (t
)
3591 /* Specializations have already had their names set up in
3592 lookup_template_class. */
3593 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
3595 tree tmpl
= most_general_template (CLASSTYPE_TI_TEMPLATE (t
));
3597 /* For non-primary templates, the template parameters are
3598 implicit from their surrounding context. */
3599 if (PRIMARY_TEMPLATE_P (tmpl
))
3601 tree name
= DECL_NAME (tmpl
);
3602 char *mangled_name
= mangle_class_name_for_template
3603 (IDENTIFIER_POINTER (name
),
3604 DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
3605 CLASSTYPE_TI_ARGS (t
));
3606 tree id
= get_identifier (mangled_name
);
3607 IDENTIFIER_TEMPLATE (id
) = name
;
3612 return TYPE_IDENTIFIER (t
);
3616 add_pending_template (d
)
3621 if (TREE_CODE_CLASS (TREE_CODE (d
)) == 't')
3622 ti
= CLASSTYPE_TEMPLATE_INFO (d
);
3624 ti
= DECL_TEMPLATE_INFO (d
);
3626 if (TI_PENDING_TEMPLATE_FLAG (ti
))
3629 *template_tail
= tree_cons (build_srcloc_here (), d
, NULL_TREE
);
3630 template_tail
= &TREE_CHAIN (*template_tail
);
3631 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
3635 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3636 may be either a _DECL or an overloaded function or an
3637 IDENTIFIER_NODE), and ARGLIST. */
3640 lookup_template_function (fns
, arglist
)
3645 if (fns
== NULL_TREE
)
3647 cp_error ("non-template used as template");
3648 return error_mark_node
;
3651 type
= TREE_TYPE (fns
);
3652 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
3653 type
= unknown_type_node
;
3655 if (processing_template_decl
)
3656 return build_min (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3658 return build (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3661 /* Within the scope of a template class S<T>, the name S gets bound
3662 (in build_self_reference) to a TYPE_DECL for the class, not a
3663 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3664 or one of its enclosing classes, and that type is a template,
3665 return the associated TEMPLATE_DECL. Otherwise, the original
3666 DECL is returned. */
3669 maybe_get_template_decl_from_type_decl (decl
)
3672 return (decl
!= NULL_TREE
3673 && TREE_CODE (decl
) == TYPE_DECL
3674 && DECL_ARTIFICIAL (decl
)
3675 && CLASS_TYPE_P (TREE_TYPE (decl
))
3676 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
3677 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
3680 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3681 parameters, find the desired type.
3683 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3684 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3685 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3686 otherwise.) Since ARGLIST is build on the decl_obstack, we must
3687 copy it here to keep it from being reclaimed when the decl storage
3690 IN_DECL, if non-NULL, is the template declaration we are trying to
3693 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3694 the class we are looking up.
3696 If the template class is really a local class in a template
3697 function, then the FUNCTION_CONTEXT is the function in which it is
3698 being instantiated. */
3701 lookup_template_class (d1
, arglist
, in_decl
, context
, entering_scope
)
3707 tree
template = NULL_TREE
, parmlist
;
3710 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
3712 if (IDENTIFIER_VALUE (d1
)
3713 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1
)))
3714 template = IDENTIFIER_VALUE (d1
);
3718 push_decl_namespace (context
);
3719 template = lookup_name (d1
, /*prefer_type=*/0);
3720 template = maybe_get_template_decl_from_type_decl (template);
3722 pop_decl_namespace ();
3725 context
= DECL_CONTEXT (template);
3727 else if (TREE_CODE (d1
) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (d1
)))
3729 tree type
= TREE_TYPE (d1
);
3731 /* If we are declaring a constructor, say A<T>::A<T>, we will get
3732 an implicit typename for the second A. Deal with it. */
3733 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
3734 type
= TREE_TYPE (type
);
3736 if (CLASSTYPE_TEMPLATE_INFO (type
))
3738 template = CLASSTYPE_TI_TEMPLATE (type
);
3739 d1
= DECL_NAME (template);
3742 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
3743 || (TREE_CODE_CLASS (TREE_CODE (d1
)) == 't'
3744 && IS_AGGR_TYPE (d1
)))
3746 template = TYPE_TI_TEMPLATE (d1
);
3747 d1
= DECL_NAME (template);
3749 else if (TREE_CODE (d1
) == TEMPLATE_DECL
3750 && TREE_CODE (DECL_RESULT (d1
)) == TYPE_DECL
)
3753 d1
= DECL_NAME (template);
3754 context
= DECL_CONTEXT (template);
3757 my_friendly_abort (272);
3759 /* With something like `template <class T> class X class X { ... };'
3760 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3761 We don't want to do that, but we have to deal with the situation,
3762 so let's give them some syntax errors to chew on instead of a
3766 cp_error ("`%T' is not a template", d1
);
3767 return error_mark_node
;
3770 if (context
== NULL_TREE
)
3771 context
= global_namespace
;
3773 if (TREE_CODE (template) != TEMPLATE_DECL
)
3775 cp_error ("non-template type `%T' used as a template", d1
);
3777 cp_error_at ("for template declaration `%D'", in_decl
);
3778 return error_mark_node
;
3781 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
3783 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3784 template arguments */
3786 tree parm
= copy_template_template_parm (TREE_TYPE (template));
3787 tree template2
= TYPE_STUB_DECL (parm
);
3790 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
3792 arglist2
= coerce_template_parms (parmlist
, arglist
, template, 1, 1);
3793 if (arglist2
== error_mark_node
)
3794 return error_mark_node
;
3796 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
)
3797 = tree_cons (template2
, arglist2
, NULL_TREE
);
3798 TYPE_SIZE (parm
) = 0;
3803 tree template_type
= TREE_TYPE (template);
3806 tree found
= NULL_TREE
;
3809 int is_partial_instantiation
;
3811 gen_tmpl
= most_general_template (template);
3812 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
3813 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
3814 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3816 /* We build up the coerced arguments and such on the
3817 momentary_obstack. */
3820 if (arg_depth
== 1 && parm_depth
> 1)
3822 /* We've been given an incomplete set of template arguments.
3825 template <class T> struct S1 {
3826 template <class U> struct S2 {};
3827 template <class U> struct S2<U*> {};
3830 we will be called with an ARGLIST of `U*', but the
3831 TEMPLATE will be `template <class T> template
3832 <class U> struct S1<T>::S2'. We must fill in the missing
3835 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
3837 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3840 /* Now we should enough arguments. */
3841 my_friendly_assert (parm_depth
== arg_depth
, 0);
3843 /* From here on, we're only interested in the most general
3845 template = gen_tmpl
;
3847 /* Calculate the BOUND_ARGS. These will be the args that are
3848 actually tsubst'd into the definition to create the
3852 /* We have multiple levels of arguments to coerce, at once. */
3854 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
3856 tree bound_args
= make_temp_vec (parm_depth
);
3858 for (i
= saved_depth
,
3859 t
= DECL_TEMPLATE_PARMS (template);
3860 i
> 0 && t
!= NULL_TREE
;
3861 --i
, t
= TREE_CHAIN (t
))
3863 tree a
= coerce_template_parms (TREE_VALUE (t
),
3864 arglist
, template, 1, 1);
3865 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
3867 /* We temporarily reduce the length of the ARGLIST so
3868 that coerce_template_parms will see only the arguments
3869 corresponding to the template parameters it is
3871 TREE_VEC_LENGTH (arglist
)--;
3874 /* Restore the ARGLIST to its full size. */
3875 TREE_VEC_LENGTH (arglist
) = saved_depth
;
3877 arglist
= bound_args
;
3881 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
3882 innermost_args (arglist
),
3885 if (arglist
== error_mark_node
)
3886 /* We were unable to bind the arguments. */
3887 return error_mark_node
;
3889 /* In the scope of a template class, explicit references to the
3890 template class refer to the type of the template, not any
3891 instantiation of it. For example, in:
3893 template <class T> class C { void f(C<T>); }
3895 the `C<T>' is just the same as `C'. Outside of the
3896 class, however, such a reference is an instantiation. */
3897 if (comp_template_args (TYPE_TI_ARGS (template_type
),
3900 found
= template_type
;
3902 if (!entering_scope
&& PRIMARY_TEMPLATE_P (template))
3906 /* Note that we use DECL_CONTEXT, rather than
3907 CP_DECL_CONTEXT, so that the termination test is
3908 always just `ctx'. We're not interested in namepace
3910 for (ctx
= current_class_type
;
3912 ctx
= (TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't')
3913 ? TYPE_CONTEXT (ctx
) : DECL_CONTEXT (ctx
))
3914 if (same_type_p (ctx
, template_type
))
3918 /* We're not in the scope of the class, so the
3919 TEMPLATE_TYPE is not the type we want after
3927 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3928 found
; found
= TREE_CHAIN (found
))
3929 if (comp_template_args (TREE_PURPOSE (found
), arglist
))
3933 found
= TREE_VALUE (found
);
3942 /* This type is a "partial instantiation" if any of the template
3943 arguments still inolve template parameters. Note that we set
3944 IS_PARTIAL_INSTANTIATION for partial specializations as
3946 is_partial_instantiation
= uses_template_parms (arglist
);
3948 if (!is_partial_instantiation
3949 && !PRIMARY_TEMPLATE_P (template)
3950 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL
)
3953 found
= xref_tag_from_type (TREE_TYPE (template),
3954 DECL_NAME (template),
3959 /* Since we didn't find the type, we'll have to create it.
3960 Since we'll be saving this type on the
3961 DECL_TEMPLATE_INSTANTIATIONS list, it must be permanent. */
3962 push_obstacks (&permanent_obstack
, &permanent_obstack
);
3964 /* Create the type. */
3965 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
3967 if (!is_partial_instantiation
)
3968 t
= start_enum (TYPE_IDENTIFIER (template_type
));
3970 /* We don't want to call start_enum for this type, since
3971 the values for the enumeration constants may involve
3972 template parameters. And, no one should be interested
3973 in the enumeration constants for such a type. */
3974 t
= make_node (ENUMERAL_TYPE
);
3978 t
= make_lang_type (TREE_CODE (template_type
));
3979 CLASSTYPE_DECLARED_CLASS (t
)
3980 = CLASSTYPE_DECLARED_CLASS (template_type
);
3981 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
3982 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
3983 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
3986 /* If we called start_enum above, this information will already
3990 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3992 type_decl
= create_implicit_typedef (DECL_NAME (template), t
);
3993 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
3994 TYPE_STUB_DECL (t
) = type_decl
;
3995 DECL_SOURCE_FILE (type_decl
)
3996 = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type
));
3997 DECL_SOURCE_LINE (type_decl
)
3998 = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type
));
4001 type_decl
= TYPE_NAME (t
);
4003 /* Set up the template information. We have to figure out which
4004 template is the immediate parent if this is a full
4006 if (parm_depth
== 1 || is_partial_instantiation
4007 || !PRIMARY_TEMPLATE_P (template))
4008 /* This case is easy; there are no member templates involved. */
4012 /* This is a full instantiation of a member template. There
4013 should be some partial instantiation of which this is an
4016 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
4017 found
; found
= TREE_CHAIN (found
))
4020 tree tmpl
= CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found
));
4022 /* We only want partial instantiations, here, not
4023 specializations or full instantiations. */
4024 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found
))
4025 || !uses_template_parms (TREE_VALUE (found
)))
4028 /* Temporarily reduce by one the number of levels in the
4029 ARGLIST and in FOUND so as to avoid comparing the
4030 last set of arguments. */
4031 TREE_VEC_LENGTH (arglist
)--;
4032 TREE_VEC_LENGTH (TREE_PURPOSE (found
)) --;
4034 /* See if the arguments match. If they do, then TMPL is
4035 the partial instantiation we want. */
4036 success
= comp_template_args (TREE_PURPOSE (found
), arglist
);
4038 /* Restore the argument vectors to their full size. */
4039 TREE_VEC_LENGTH (arglist
)++;
4040 TREE_VEC_LENGTH (TREE_PURPOSE (found
))++;
4050 my_friendly_abort (0);
4053 SET_TYPE_TEMPLATE_INFO (t
,
4054 tree_cons (found
, arglist
, NULL_TREE
));
4055 DECL_TEMPLATE_INSTANTIATIONS (template)
4056 = tree_cons (arglist
, t
,
4057 DECL_TEMPLATE_INSTANTIATIONS (template));
4059 if (TREE_CODE (t
) == ENUMERAL_TYPE
4060 && !is_partial_instantiation
)
4061 /* Now that the type has been registered on the instantiations
4062 list, we set up the enumerators. Because the enumeration
4063 constants may involve the enumeration type itself, we make
4064 sure to register the type first, and then create the
4065 constants. That way, doing tsubst_expr for the enumeration
4066 constants won't result in recursive calls here; we'll find
4067 the instantiation and exit above. */
4068 tsubst_enum (template_type
, t
, arglist
);
4070 /* We're done with the permanent obstack, now. */
4072 /* We're also done with the momentary allocation we started
4076 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4078 if (TREE_CODE (t
) != ENUMERAL_TYPE
)
4079 DECL_NAME (type_decl
) = classtype_mangled_name (t
);
4080 DECL_ASSEMBLER_NAME (type_decl
) = DECL_NAME (type_decl
);
4081 if (!is_partial_instantiation
)
4083 DECL_ASSEMBLER_NAME (type_decl
)
4084 = get_identifier (build_overload_name (t
, 1, 1));
4086 /* For backwards compatibility; code that uses
4087 -fexternal-templates expects looking up a template to
4088 instantiate it. I think DDD still relies on this.
4089 (jason 8/20/1998) */
4090 if (TREE_CODE (t
) != ENUMERAL_TYPE
4091 && flag_external_templates
4092 && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template))
4093 && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template)))
4094 add_pending_template (t
);
4097 /* If the type makes use of template parameters, the
4098 code that generates debugging information will crash. */
4099 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
4105 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, or
4106 TEMPLATE_PARM_INDEX in T, call FN with the parameter and the DATA.
4107 If FN returns non-zero, the iteration is terminated, and
4108 for_each_template_parm returns 1. Otherwise, the iteration
4109 continues. If FN never returns a non-zero value, the value
4110 returned by for_each_template_parm is 0. If FN is NULL, it is
4111 considered to be the function which always returns 1. */
4114 for_each_template_parm (t
, fn
, data
)
4122 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't'
4123 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
))
4126 switch (TREE_CODE (t
))
4130 return (for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
)
4131 || for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
));
4133 case IDENTIFIER_NODE
:
4134 if (!IDENTIFIER_TEMPLATE (t
))
4136 my_friendly_abort (42);
4138 /* aggregates of tree nodes */
4141 int i
= TREE_VEC_LENGTH (t
);
4143 if (for_each_template_parm (TREE_VEC_ELT (t
, i
), fn
, data
))
4148 if (for_each_template_parm (TREE_PURPOSE (t
), fn
, data
)
4149 || for_each_template_parm (TREE_VALUE (t
), fn
, data
))
4151 return for_each_template_parm (TREE_CHAIN (t
), fn
, data
);
4154 if (for_each_template_parm (OVL_FUNCTION (t
), fn
, data
))
4156 return for_each_template_parm (OVL_CHAIN (t
), fn
, data
);
4158 /* constructed type nodes */
4160 case REFERENCE_TYPE
:
4161 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4164 if (TYPE_PTRMEMFUNC_FLAG (t
))
4165 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE (t
),
4171 if (! TYPE_TEMPLATE_INFO (t
))
4173 return for_each_template_parm (TREE_VALUE
4174 (TYPE_TEMPLATE_INFO (t
)),
4177 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
))
4182 /* Check the parameter types. Since default arguments are not
4183 instantiated until they are needed, the TYPE_ARG_TYPES may
4184 contain expressions that involve template parameters. But,
4185 no-one should be looking at them yet. And, once they're
4186 instantiated, they don't contain template parameters, so
4187 there's no point in looking at them then, either. */
4191 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
4192 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
))
4196 /* Check the return type, too. */
4197 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4200 if (for_each_template_parm (TYPE_DOMAIN (t
), fn
, data
))
4202 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4204 if (for_each_template_parm (TYPE_OFFSET_BASETYPE (t
), fn
, data
))
4206 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4210 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4213 /* A template template parameter is encountered */
4214 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
4215 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4216 /* Already substituted template template parameter */
4220 if (for_each_template_parm (DECL_INITIAL (t
), fn
, data
))
4222 goto check_type_and_context
;
4226 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
4227 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
))
4231 check_type_and_context
:
4232 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
))
4234 if (DECL_CONTEXT (t
)
4235 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
))
4240 return (for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
)
4241 || for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
));
4244 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4246 /* template parm nodes */
4247 case TEMPLATE_TEMPLATE_PARM
:
4248 /* Record template parameters such as `T' inside `TT<T>'. */
4249 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
)
4250 && for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
))
4252 case TEMPLATE_TYPE_PARM
:
4253 case TEMPLATE_PARM_INDEX
:
4255 return (*fn
)(t
, data
);
4259 /* simple type nodes */
4261 if (for_each_template_parm (TYPE_MIN_VALUE (t
), fn
, data
))
4263 return for_each_template_parm (TYPE_MAX_VALUE (t
), fn
, data
);
4269 case NAMESPACE_DECL
:
4280 /* Non-error_mark_node ERROR_MARKs are bad things. */
4281 my_friendly_assert (t
== error_mark_node
, 274);
4286 return for_each_template_parm (TREE_TYPE (t
), fn
, data
);
4289 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4292 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
4293 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4294 (TREE_TYPE (t
)), fn
, data
);
4295 return for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
);
4299 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4304 return (for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
)
4305 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
),
4310 /* If there's no type, then this thing must be some expression
4311 involving template parameters. */
4312 if (!fn
&& !TREE_TYPE (t
))
4314 if (TREE_CODE (t
) == COMPONENT_REF
)
4315 return (for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
)
4316 || for_each_template_parm (TREE_OPERAND (t
, 1), fn
, data
));
4318 return for_each_template_parm (TREE_OPERAND (t
, 0), fn
, data
);
4322 case REINTERPRET_CAST_EXPR
:
4323 case CONST_CAST_EXPR
:
4324 case STATIC_CAST_EXPR
:
4325 case DYNAMIC_CAST_EXPR
:
4330 case PSEUDO_DTOR_EXPR
:
4336 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
4344 for (i
= first_rtl_op (TREE_CODE (t
)); --i
>= 0;)
4345 if (for_each_template_parm (TREE_OPERAND (t
, i
), fn
, data
))
4352 sorry ("testing %s for template parms",
4353 tree_code_name
[(int) TREE_CODE (t
)]);
4354 my_friendly_abort (82);
4361 uses_template_parms (t
)
4364 return for_each_template_parm (t
, 0, 0);
4367 static struct tinst_level
*current_tinst_level
;
4368 static struct tinst_level
*free_tinst_level
;
4369 static int tinst_depth
;
4370 extern int max_tinst_depth
;
4371 #ifdef GATHER_STATISTICS
4374 int tinst_level_tick
;
4375 int last_template_error_tick
;
4377 /* Print out all the template instantiations that we are currently
4378 working on. If ERR, we are being called from cp_thing, so do
4379 the right thing for an error message. */
4382 print_template_context (err
)
4385 struct tinst_level
*p
= current_tinst_level
;
4387 char *file
= input_filename
;
4391 if (current_function_decl
!= p
->decl
4392 && current_function_decl
!= NULL_TREE
)
4393 /* We can get here during the processing of some synthesized
4394 method. Then, p->decl will be the function that's causing
4399 if (current_function_decl
== p
->decl
)
4400 /* Avoid redundancy with the the "In function" line. */;
4402 fprintf (stderr
, "%s: In instantiation of `%s':\n",
4403 file
, decl_as_string (p
->decl
, TS_DECL_TYPE
| TS_FUNC_NORETURN
));
4411 for (; p
; p
= p
->next
)
4413 fprintf (stderr
, "%s:%d: instantiated from `%s'\n", file
, line
,
4414 decl_as_string (p
->decl
, TS_DECL_TYPE
| TS_FUNC_NORETURN
));
4418 fprintf (stderr
, "%s:%d: instantiated from here\n", file
, line
);
4421 /* Called from cp_thing to print the template context for an error. */
4424 maybe_print_template_context ()
4426 if (last_template_error_tick
== tinst_level_tick
4427 || current_tinst_level
== 0)
4430 last_template_error_tick
= tinst_level_tick
;
4431 print_template_context (1);
4435 push_tinst_level (d
)
4438 struct tinst_level
*new;
4440 if (tinst_depth
>= max_tinst_depth
)
4442 /* If the instantiation in question still has unbound template parms,
4443 we don't really care if we can't instantiate it, so just return.
4444 This happens with base instantiation for implicit `typename'. */
4445 if (uses_template_parms (d
))
4448 last_template_error_tick
= tinst_level_tick
;
4449 error ("template instantiation depth exceeds maximum of %d",
4451 error (" (use -ftemplate-depth-NN to increase the maximum)");
4452 cp_error (" instantiating `%D'", d
);
4454 print_template_context (0);
4459 if (free_tinst_level
)
4461 new = free_tinst_level
;
4462 free_tinst_level
= new->next
;
4465 new = (struct tinst_level
*) xmalloc (sizeof (struct tinst_level
));
4469 new->file
= input_filename
;
4470 new->next
= current_tinst_level
;
4471 current_tinst_level
= new;
4474 #ifdef GATHER_STATISTICS
4475 if (tinst_depth
> depth_reached
)
4476 depth_reached
= tinst_depth
;
4486 struct tinst_level
*old
= current_tinst_level
;
4488 /* Restore the filename and line number stashed away when we started
4489 this instantiation. */
4491 input_filename
= old
->file
;
4492 extract_interface_info ();
4494 current_tinst_level
= old
->next
;
4495 old
->next
= free_tinst_level
;
4496 free_tinst_level
= old
;
4501 struct tinst_level
*
4504 struct tinst_level
*p
= current_tinst_level
;
4507 for (; p
->next
; p
= p
->next
)
4512 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4513 vector of template arguments, as for tsubst.
4515 Returns an appropriate tsbust'd friend declaration. */
4518 tsubst_friend_function (decl
, args
)
4524 char *file
= input_filename
;
4526 lineno
= DECL_SOURCE_LINE (decl
);
4527 input_filename
= DECL_SOURCE_FILE (decl
);
4529 if (TREE_CODE (decl
) == FUNCTION_DECL
4530 && DECL_TEMPLATE_INSTANTIATION (decl
)
4531 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
4532 /* This was a friend declared with an explicit template
4533 argument list, e.g.:
4537 to indicate that f was a template instantiation, not a new
4538 function declaration. Now, we have to figure out what
4539 instantiation of what template. */
4546 = lookup_template_function (tsubst_expr (DECL_TI_TEMPLATE (decl
),
4547 args
, /*complain=*/1,
4549 tsubst (DECL_TI_ARGS (decl
),
4550 args
, /*complain=*/1,
4552 new_friend
= tsubst (decl
, args
, /*complain=*/1, NULL_TREE
);
4553 tmpl
= determine_specialization (template_id
, new_friend
,
4555 /*need_member_template=*/0);
4556 new_friend
= instantiate_template (tmpl
, new_args
);
4560 new_friend
= tsubst (decl
, args
, /*complain=*/1, NULL_TREE
);
4562 /* The NEW_FRIEND will look like an instantiation, to the
4563 compiler, but is not an instantiation from the point of view of
4564 the language. For example, we might have had:
4566 template <class T> struct S {
4567 template <class U> friend void f(T, U);
4570 Then, in S<int>, template <class U> void f(int, U) is not an
4571 instantiation of anything. */
4572 DECL_USE_TEMPLATE (new_friend
) = 0;
4573 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4574 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
4576 /* The mangled name for the NEW_FRIEND is incorrect. The call to
4577 tsubst will have resulted in a call to
4578 set_mangled_name_for_template_decl. But, the function is not a
4579 template instantiation and should not be mangled like one.
4580 Therefore, we remangle the function name. We don't have to do
4581 this if the NEW_FRIEND is a template since
4582 set_mangled_name_for_template_decl doesn't do anything if the
4583 function declaration still uses template arguments. */
4584 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
4586 set_mangled_name_for_decl (new_friend
);
4587 DECL_RTL (new_friend
) = 0;
4588 make_decl_rtl (new_friend
, NULL_PTR
, 1);
4591 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
4594 tree new_friend_template_info
;
4595 tree new_friend_result_template_info
;
4597 int new_friend_is_defn
;
4599 /* We must save some information from NEW_FRIEND before calling
4600 duplicate decls since that function will free NEW_FRIEND if
4602 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
4603 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
4605 /* This declaration is a `primary' template. */
4606 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
4609 = DECL_INITIAL (DECL_RESULT (new_friend
)) != NULL_TREE
;
4610 new_friend_result_template_info
4611 = DECL_TEMPLATE_INFO (DECL_RESULT (new_friend
));
4615 new_friend_is_defn
= DECL_INITIAL (new_friend
) != NULL_TREE
;
4616 new_friend_result_template_info
= NULL_TREE
;
4619 /* Inside pushdecl_namespace_level, we will push into the
4620 current namespace. However, the friend function should
4621 tyically go into the namespace of the template. */
4622 ns
= decl_namespace_context (new_friend
);
4623 push_nested_namespace (ns
);
4624 old_decl
= pushdecl_namespace_level (new_friend
);
4625 pop_nested_namespace (ns
);
4627 if (old_decl
!= new_friend
)
4629 /* This new friend declaration matched an existing
4630 declaration. For example, given:
4632 template <class T> void f(T);
4633 template <class U> class C {
4634 template <class T> friend void f(T) {}
4637 the friend declaration actually provides the definition
4638 of `f', once C has been instantiated for some type. So,
4639 old_decl will be the out-of-class template declaration,
4640 while new_friend is the in-class definition.
4642 But, if `f' was called before this point, the
4643 instantiation of `f' will have DECL_TI_ARGS corresponding
4644 to `T' but not to `U', references to which might appear
4645 in the definition of `f'. Previously, the most general
4646 template for an instantiation of `f' was the out-of-class
4647 version; now it is the in-class version. Therefore, we
4648 run through all specialization of `f', adding to their
4649 DECL_TI_ARGS appropriately. In particular, they need a
4650 new set of outer arguments, corresponding to the
4651 arguments for this class instantiation.
4653 The same situation can arise with something like this:
4656 template <class T> class C {
4660 when `C<int>' is instantiated. Now, `f(int)' is defined
4663 if (!new_friend_is_defn
)
4664 /* On the other hand, if the in-class declaration does
4665 *not* provide a definition, then we don't want to alter
4666 existing definitions. We can just leave everything
4671 /* Overwrite whatever template info was there before, if
4672 any, with the new template information pertaining to
4674 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
4676 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
4677 /* duplicate_decls will take care of this case. */
4682 tree new_friend_args
;
4684 DECL_TEMPLATE_INFO (DECL_RESULT (old_decl
))
4685 = new_friend_result_template_info
;
4687 new_friend_args
= TI_ARGS (new_friend_template_info
);
4688 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (old_decl
);
4692 tree spec
= TREE_VALUE (t
);
4695 = add_outermost_template_args (new_friend_args
,
4696 DECL_TI_ARGS (spec
));
4699 /* Now, since specializations are always supposed to
4700 hang off of the most general template, we must move
4702 t
= most_general_template (old_decl
);
4705 DECL_TEMPLATE_SPECIALIZATIONS (t
)
4706 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t
),
4707 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
));
4708 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
) = NULL_TREE
;
4713 /* The information from NEW_FRIEND has been merged into OLD_DECL
4714 by duplicate_decls. */
4715 new_friend
= old_decl
;
4718 else if (TYPE_SIZE (DECL_CONTEXT (new_friend
)))
4720 /* Check to see that the declaration is really present, and,
4721 possibly obtain an improved declaration. */
4722 tree fn
= check_classfn (DECL_CONTEXT (new_friend
),
4731 input_filename
= file
;
4735 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4736 template arguments, as for tsubst.
4738 Returns an appropriate tsbust'd friend type. */
4741 tsubst_friend_class (friend_tmpl
, args
)
4748 /* First, we look for a class template. */
4749 tmpl
= lookup_name (DECL_NAME (friend_tmpl
), /*prefer_type=*/0);
4751 /* But, if we don't find one, it might be because we're in a
4752 situation like this:
4760 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
4761 for `S<int>', not the TEMPLATE_DECL. */
4762 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
4764 tmpl
= lookup_name (DECL_NAME (friend_tmpl
), /*prefer_type=*/1);
4765 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
4768 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
4770 /* The friend template has already been declared. Just
4771 check to see that the declarations match, and install any new
4772 default parameters. We must tsubst the default parameters,
4773 of course. We only need the innermost template parameters
4774 because that is all that redeclare_class_template will look
4777 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
4778 args
, /*complain=*/1);
4779 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
4780 friend_type
= TREE_TYPE (tmpl
);
4784 /* The friend template has not already been declared. In this
4785 case, the instantiation of the template class will cause the
4786 injection of this template into the global scope. */
4787 tmpl
= tsubst (friend_tmpl
, args
, /*complain=*/1, NULL_TREE
);
4789 /* The new TMPL is not an instantiation of anything, so we
4790 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4791 the new type because that is supposed to be the corresponding
4792 template decl, i.e., TMPL. */
4793 DECL_USE_TEMPLATE (tmpl
) = 0;
4794 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
4795 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
4797 /* Inject this template into the global scope. */
4798 friend_type
= TREE_TYPE (pushdecl_top_level (tmpl
));
4805 instantiate_class_template (type
)
4808 tree
template, args
, pattern
, t
;
4811 if (type
== error_mark_node
)
4812 return error_mark_node
;
4814 if (TYPE_BEING_DEFINED (type
) || TYPE_SIZE (type
))
4817 /* We want to allocate temporary vectors of template arguments and
4818 template argument expressions on the momentary obstack, not on
4819 the expression obstack. Otherwise, all the space allocated in
4820 argument coercion and such is simply lost. */
4823 /* Figure out which template is being instantiated. */
4824 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
4825 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL
, 279);
4827 /* Figure out which arguments are being used to do the
4829 args
= CLASSTYPE_TI_ARGS (type
);
4830 PARTIAL_INSTANTIATION_P (type
) = uses_template_parms (args
);
4832 if (pedantic
&& PARTIAL_INSTANTIATION_P (type
))
4833 /* If this is a partial instantiation, then we can't instantiate
4834 the type; there's no telling whether or not one of the
4835 template parameters might eventually be instantiated to some
4836 value that results in a specialization being used. For
4848 Now, the `S<U>' in `f<int>' is the specialization, not an
4849 instantiation of the original template. */
4852 /* Determine what specialization of the original template to
4854 if (PARTIAL_INSTANTIATION_P (type
))
4855 /* There's no telling which specialization is appropriate at this
4856 point. Since all peeking at the innards of this partial
4857 instantiation are extensions (like the "implicit typename"
4858 extension, which allows users to omit the keyword `typename' on
4859 names that are declared as types in template base classes), we
4860 are free to do what we please.
4862 Trying to figure out which partial instantiation to use can
4863 cause a crash. (Some of the template arguments don't even have
4864 types.) So, we just use the most general version. */
4868 t
= most_specialized_class (template, args
);
4870 if (t
== error_mark_node
)
4872 const char *str
= "candidates are:";
4873 cp_error ("ambiguous class template instantiation for `%#T'", type
);
4874 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (template); t
;
4877 if (get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4880 cp_error_at ("%s %+#T", str
, TREE_TYPE (t
));
4884 TYPE_BEING_DEFINED (type
) = 1;
4885 type
= error_mark_node
;
4891 pattern
= TREE_TYPE (t
);
4893 pattern
= TREE_TYPE (template);
4895 /* If the template we're instantiating is incomplete, then clearly
4896 there's nothing we can do. */
4897 if (TYPE_SIZE (pattern
) == NULL_TREE
)
4900 /* If this is a partial instantiation, don't tsubst anything. We will
4901 only use this type for implicit typename, so the actual contents don't
4902 matter. All that matters is whether a particular name is a type. */
4903 if (PARTIAL_INSTANTIATION_P (type
))
4905 /* The fields set here must be kept in sync with those cleared
4906 in begin_class_definition. */
4907 TYPE_BINFO_BASETYPES (type
) = TYPE_BINFO_BASETYPES (pattern
);
4908 TYPE_FIELDS (type
) = TYPE_FIELDS (pattern
);
4909 TYPE_METHODS (type
) = TYPE_METHODS (pattern
);
4910 CLASSTYPE_TAGS (type
) = CLASSTYPE_TAGS (pattern
);
4911 /* Pretend that the type is complete, so that we will look
4912 inside it during name lookup and such. */
4913 TYPE_SIZE (type
) = integer_zero_node
;
4917 /* If we've recursively instantiated too many templates, stop. */
4918 if (! push_tinst_level (type
))
4921 /* Now we're really doing the instantiation. Mark the type as in
4922 the process of being defined. */
4923 TYPE_BEING_DEFINED (type
) = 1;
4925 maybe_push_to_top_level (uses_template_parms (type
));
4929 /* This TYPE is actually a instantiation of of a partial
4930 specialization. We replace the innermost set of ARGS with
4931 the arguments appropriate for substitution. For example,
4934 template <class T> struct S {};
4935 template <class T> struct S<T*> {};
4937 and supposing that we are instantiating S<int*>, ARGS will
4938 present be {int*} but we need {int}. */
4940 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4943 /* If there were multiple levels in ARGS, replacing the
4944 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4945 want, so we make a copy first. */
4946 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
4948 args
= copy_node (args
);
4949 SET_TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
), inner_args
);
4955 if (flag_external_templates
)
4957 if (flag_alt_external_templates
)
4959 CLASSTYPE_INTERFACE_ONLY (type
) = interface_only
;
4960 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type
, interface_unknown
);
4961 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4962 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4963 && CLASSTYPE_INTERFACE_KNOWN (type
));
4967 CLASSTYPE_INTERFACE_ONLY (type
) = CLASSTYPE_INTERFACE_ONLY (pattern
);
4968 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
4969 (type
, CLASSTYPE_INTERFACE_UNKNOWN (pattern
));
4970 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4971 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4972 && CLASSTYPE_INTERFACE_KNOWN (type
));
4977 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
4978 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 1;
4981 TYPE_HAS_CONSTRUCTOR (type
) = TYPE_HAS_CONSTRUCTOR (pattern
);
4982 TYPE_HAS_DESTRUCTOR (type
) = TYPE_HAS_DESTRUCTOR (pattern
);
4983 TYPE_OVERLOADS_CALL_EXPR (type
) = TYPE_OVERLOADS_CALL_EXPR (pattern
);
4984 TYPE_OVERLOADS_ARRAY_REF (type
) = TYPE_OVERLOADS_ARRAY_REF (pattern
);
4985 TYPE_OVERLOADS_ARROW (type
) = TYPE_OVERLOADS_ARROW (pattern
);
4986 TYPE_GETS_NEW (type
) = TYPE_GETS_NEW (pattern
);
4987 TYPE_GETS_DELETE (type
) = TYPE_GETS_DELETE (pattern
);
4988 TYPE_VEC_DELETE_TAKES_SIZE (type
) = TYPE_VEC_DELETE_TAKES_SIZE (pattern
);
4989 TYPE_HAS_ASSIGN_REF (type
) = TYPE_HAS_ASSIGN_REF (pattern
);
4990 TYPE_HAS_CONST_ASSIGN_REF (type
) = TYPE_HAS_CONST_ASSIGN_REF (pattern
);
4991 TYPE_HAS_ABSTRACT_ASSIGN_REF (type
) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern
);
4992 TYPE_HAS_INIT_REF (type
) = TYPE_HAS_INIT_REF (pattern
);
4993 TYPE_HAS_CONST_INIT_REF (type
) = TYPE_HAS_CONST_INIT_REF (pattern
);
4994 TYPE_HAS_DEFAULT_CONSTRUCTOR (type
) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern
);
4995 TYPE_HAS_CONVERSION (type
) = TYPE_HAS_CONVERSION (pattern
);
4996 TYPE_USES_COMPLEX_INHERITANCE (type
)
4997 = TYPE_USES_COMPLEX_INHERITANCE (pattern
);
4998 TYPE_USES_MULTIPLE_INHERITANCE (type
)
4999 = TYPE_USES_MULTIPLE_INHERITANCE (pattern
);
5000 TYPE_USES_VIRTUAL_BASECLASSES (type
)
5001 = TYPE_USES_VIRTUAL_BASECLASSES (pattern
);
5002 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
5003 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
5004 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
5005 if (ANON_AGGR_TYPE_P (pattern
))
5006 SET_ANON_AGGR_TYPE_P (type
);
5008 if (TYPE_BINFO_BASETYPES (pattern
))
5010 tree base_list
= NULL_TREE
;
5011 tree pbases
= TYPE_BINFO_BASETYPES (pattern
);
5014 /* Substitute into each of the bases to determine the actual
5016 for (i
= 0; i
< TREE_VEC_LENGTH (pbases
); ++i
)
5022 pbase
= TREE_VEC_ELT (pbases
, i
);
5024 /* Substitue to figure out the base class. */
5025 base
= tsubst (BINFO_TYPE (pbase
), args
,
5026 /*complain=*/1, NULL_TREE
);
5027 if (base
== error_mark_node
)
5030 /* Calculate the correct access node. */
5031 if (TREE_VIA_VIRTUAL (pbase
))
5033 if (TREE_VIA_PUBLIC (pbase
))
5034 access
= access_public_virtual_node
;
5035 else if (TREE_VIA_PROTECTED (pbase
))
5036 access
= access_protected_virtual_node
;
5038 access
= access_private_virtual_node
;
5042 if (TREE_VIA_PUBLIC (pbase
))
5043 access
= access_public_node
;
5044 else if (TREE_VIA_PROTECTED (pbase
))
5045 access
= access_protected_node
;
5047 access
= access_private_node
;
5050 base_list
= tree_cons (access
, base
, base_list
);
5053 /* The list is now in reverse order; correct that. */
5054 base_list
= nreverse (base_list
);
5056 /* Now call xref_basetypes to set up all the base-class
5058 xref_basetypes (TREE_CODE (pattern
) == RECORD_TYPE
5059 ? (CLASSTYPE_DECLARED_CLASS (pattern
)
5060 ? class_type_node
: record_type_node
)
5062 DECL_NAME (TYPE_NAME (pattern
)),
5067 /* Now that our base classes are set up, enter the scope of the
5068 class, so that name lookups into base classes, etc. will work
5069 corectly. This is precisely analagous to what we do in
5070 begin_class_definition when defining an ordinary non-template
5072 pushclass (type
, 1);
5074 for (t
= CLASSTYPE_TAGS (pattern
); t
; t
= TREE_CHAIN (t
))
5076 tree tag
= TREE_VALUE (t
);
5077 tree name
= TYPE_IDENTIFIER (tag
);
5080 newtag
= tsubst (tag
, args
, /*complain=*/1, NULL_TREE
);
5081 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
5083 if (TYPE_LANG_SPECIFIC (tag
) && CLASSTYPE_IS_TEMPLATE (tag
))
5084 /* Unfortunately, lookup_template_class sets
5085 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5086 instantiation (i.e., for the type of a member template
5087 class nested within a template class.) This behavior is
5088 required for maybe_process_partial_specialization to work
5089 correctly, but is not accurate in this case; the TAG is not
5090 an instantiation of anything. (The corresponding
5091 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
5092 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
5094 /* Now, we call pushtag to put this NEWTAG into the scope of
5095 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5096 pushtag calling push_template_decl. We don't have to do
5097 this for enums because it will already have been done in
5100 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
5101 pushtag (name
, newtag
, /*globalize=*/0);
5105 /* Don't replace enum constants here. */
5106 for (t
= TYPE_FIELDS (pattern
); t
; t
= TREE_CHAIN (t
))
5107 if (TREE_CODE (t
) != CONST_DECL
)
5111 /* The the file and line for this declaration, to assist in
5112 error message reporting. Since we called push_tinst_level
5113 above, we don't need to restore these. */
5114 lineno
= DECL_SOURCE_LINE (t
);
5115 input_filename
= DECL_SOURCE_FILE (t
);
5117 r
= tsubst (t
, args
, /*complain=*/1, NULL_TREE
);
5118 if (TREE_CODE (r
) == VAR_DECL
)
5122 if (DECL_DEFINED_IN_CLASS_P (r
))
5123 init
= tsubst_expr (DECL_INITIAL (t
), args
,
5124 /*complain=*/1, NULL_TREE
);
5128 finish_static_data_member_decl (r
, init
,
5129 /*asmspec_tree=*/NULL_TREE
,
5133 if (DECL_DEFINED_IN_CLASS_P (r
))
5134 check_static_variable_definition (r
, TREE_TYPE (r
));
5137 /* R will have a TREE_CHAIN if and only if it has already been
5138 processed by finish_member_declaration. This can happen
5139 if, for example, it is a TYPE_DECL for a class-scoped
5140 ENUMERAL_TYPE; such a thing will already have been added to
5141 the field list by tsubst_enum above. */
5142 if (!TREE_CHAIN (r
))
5144 set_current_access_from_decl (r
);
5145 finish_member_declaration (r
);
5149 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
5150 for this instantiation. */
5151 for (t
= TYPE_METHODS (pattern
); t
; t
= TREE_CHAIN (t
))
5153 tree r
= tsubst (t
, args
, /*complain=*/1, NULL_TREE
);
5154 set_current_access_from_decl (r
);
5155 finish_member_declaration (r
);
5158 /* Construct the DECL_FRIENDLIST for the new class type. */
5159 typedecl
= TYPE_MAIN_DECL (type
);
5160 for (t
= DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern
));
5166 for (friends
= TREE_VALUE (t
);
5167 friends
!= NULL_TREE
;
5168 friends
= TREE_CHAIN (friends
))
5169 if (TREE_PURPOSE (friends
) == error_mark_node
)
5171 tsubst_friend_function (TREE_VALUE (friends
),
5175 tsubst_copy (TREE_PURPOSE (t
), args
,
5176 /*complain=*/1, NULL_TREE
),
5177 tsubst (TREE_PURPOSE (friends
), args
,
5178 /*complain=*/1, NULL_TREE
));
5181 for (t
= CLASSTYPE_FRIEND_CLASSES (pattern
);
5185 tree friend_type
= TREE_VALUE (t
);
5186 tree new_friend_type
;
5188 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
5189 new_friend_type
= tsubst_friend_class (friend_type
, args
);
5190 else if (uses_template_parms (friend_type
))
5191 new_friend_type
= tsubst (friend_type
, args
, /*complain=*/1,
5195 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
5197 /* The call to xref_tag_from_type does injection for friend
5199 push_nested_namespace (ns
);
5201 xref_tag_from_type (friend_type
, NULL_TREE
, 1);
5202 pop_nested_namespace (ns
);
5205 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
5206 /* Trick make_friend_class into realizing that the friend
5207 we're adding is a template, not an ordinary class. It's
5208 important that we use make_friend_class since it will
5209 perform some error-checking and output cross-reference
5211 ++processing_template_decl
;
5213 make_friend_class (type
, new_friend_type
);
5215 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
5216 --processing_template_decl
;
5219 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
5220 if (TREE_CODE (t
) == FIELD_DECL
)
5222 TREE_TYPE (t
) = complete_type (TREE_TYPE (t
));
5223 require_complete_type (t
);
5226 /* Set the file and line number information to whatever is given for
5227 the class itself. This puts error messages involving generated
5228 implicit functions at a predictable point, and the same point
5229 that would be used for non-template classes. */
5230 lineno
= DECL_SOURCE_LINE (typedecl
);
5231 input_filename
= DECL_SOURCE_FILE (typedecl
);
5233 unreverse_member_declarations (type
);
5234 finish_struct_1 (type
);
5235 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
5237 /* Clear this now so repo_template_used is happy. */
5238 TYPE_BEING_DEFINED (type
) = 0;
5239 repo_template_used (type
);
5241 /* Now that the class is complete, instantiate default arguments for
5242 any member functions. We don't do this earlier because the
5243 default arguments may reference members of the class. */
5244 if (!PRIMARY_TEMPLATE_P (template))
5245 for (t
= TYPE_METHODS (type
); t
; t
= TREE_CHAIN (t
))
5246 if (TREE_CODE (t
) == FUNCTION_DECL
5247 /* Implicitly generated member functions will not have tmplate
5248 information; they are not instantiations, but instead are
5249 created "fresh" for each instantiation. */
5250 && DECL_TEMPLATE_INFO (t
))
5251 tsubst_default_arguments (t
);
5254 pop_from_top_level ();
5267 if (t1
== NULL_TREE
)
5268 return t2
== NULL_TREE
;
5269 if (t2
== NULL_TREE
)
5271 /* Don't care if one declares its arg const and the other doesn't -- the
5272 main variant of the arg type is all that matters. */
5273 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1
))
5274 != TYPE_MAIN_VARIANT (TREE_VALUE (t2
)))
5276 return list_eq (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
5279 /* If arg is a non-type template parameter that does not depend on template
5280 arguments, fold it like we weren't in the body of a template. */
5283 maybe_fold_nontype_arg (arg
)
5286 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
5287 && !uses_template_parms (arg
))
5289 /* Sometimes, one of the args was an expression involving a
5290 template constant parameter, like N - 1. Now that we've
5291 tsubst'd, we might have something like 2 - 1. This will
5292 confuse lookup_template_class, so we do constant folding
5293 here. We have to unset processing_template_decl, to
5294 fool build_expr_from_tree() into building an actual
5297 int saved_processing_template_decl
= processing_template_decl
;
5298 processing_template_decl
= 0;
5299 arg
= fold (build_expr_from_tree (arg
));
5300 processing_template_decl
= saved_processing_template_decl
;
5305 /* Return the TREE_VEC with the arguments for the innermost template header,
5306 where ARGS is either that or the VEC of VECs for all the
5310 innermost_args (args
)
5313 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
5316 /* Substitute ARGS into the vector of template arguments T. */
5319 tsubst_template_arg_vector (t
, args
, complain
)
5324 int len
= TREE_VEC_LENGTH (t
), need_new
= 0, i
;
5325 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
5327 bzero ((char *) elts
, len
* sizeof (tree
));
5329 for (i
= 0; i
< len
; i
++)
5331 if (TREE_VEC_ELT (t
, i
) != NULL_TREE
5332 && TREE_CODE (TREE_VEC_ELT (t
, i
)) == TREE_VEC
)
5333 elts
[i
] = tsubst_template_arg_vector (TREE_VEC_ELT (t
, i
),
5336 elts
[i
] = maybe_fold_nontype_arg
5337 (tsubst_expr (TREE_VEC_ELT (t
, i
), args
, complain
,
5340 if (elts
[i
] != TREE_VEC_ELT (t
, i
))
5347 t
= make_temp_vec (len
);
5348 for (i
= 0; i
< len
; i
++)
5349 TREE_VEC_ELT (t
, i
) = elts
[i
];
5354 /* Return the result of substituting ARGS into the template parameters
5355 given by PARMS. If there are m levels of ARGS and m + n levels of
5356 PARMS, then the result will contain n levels of PARMS. For
5357 example, if PARMS is `template <class T> template <class U>
5358 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5359 result will be `template <int*, double, class V>'. */
5362 tsubst_template_parms (parms
, args
, complain
)
5370 for (new_parms
= &r
;
5371 TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
5372 new_parms
= &(TREE_CHAIN (*new_parms
)),
5373 parms
= TREE_CHAIN (parms
))
5376 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
5379 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
5381 tree default_value
=
5382 TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
5384 TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
5386 TREE_VEC_ELT (new_vec
, i
)
5387 = build_tree_list (tsubst (default_value
, args
, complain
,
5389 tsubst (parm_decl
, args
, complain
,
5394 tree_cons (build_int_2 (0, (TMPL_PARMS_DEPTH (parms
)
5395 - TMPL_ARGS_DEPTH (args
))),
5396 new_vec
, NULL_TREE
);
5402 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5403 type T. If T is not an aggregate or enumeration type, it is
5404 handled as if by tsubst. IN_DECL is as for tsubst. If
5405 ENTERING_SCOPE is non-zero, T is the context for a template which
5406 we are presently tsubst'ing. Return the subsituted value. */
5409 tsubst_aggr_type (t
, args
, complain
, in_decl
, entering_scope
)
5419 switch (TREE_CODE (t
))
5422 if (TYPE_PTRMEMFUNC_P (t
))
5424 tree r
= build_ptrmemfunc_type
5425 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
));
5426 return cp_build_qualified_type_real (r
, TYPE_QUALS (t
),
5430 /* else fall through */
5433 if (TYPE_TEMPLATE_INFO (t
))
5439 /* First, determine the context for the type we are looking
5441 if (TYPE_CONTEXT (t
) != NULL_TREE
)
5442 context
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
,
5444 in_decl
, /*entering_scope=*/1);
5446 context
= NULL_TREE
;
5448 /* Then, figure out what arguments are appropriate for the
5449 type we are trying to find. For example, given:
5451 template <class T> struct S;
5452 template <class T, class U> void f(T, U) { S<U> su; }
5454 and supposing that we are instantiating f<int, double>,
5455 then our ARGS will be {int, double}, but, when looking up
5456 S we only want {double}. */
5458 argvec
= tsubst_template_arg_vector (TYPE_TI_ARGS (t
), args
,
5461 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
5465 return cp_build_qualified_type_real (r
, TYPE_QUALS (t
),
5469 /* This is not a template type, so there's nothing to do. */
5473 return tsubst (t
, args
, complain
, in_decl
);
5477 /* Substitute into the default argument ARG (a default argument for
5478 FN), which has the indicated TYPE. */
5481 tsubst_default_argument (fn
, type
, arg
)
5486 /* This default argument came from a template. Instantiate the
5487 default argument here, not in tsubst. In the case of
5496 we must be careful to do name lookup in the scope of S<T>,
5497 rather than in the current class. */
5498 if (DECL_CLASS_SCOPE_P (fn
))
5499 pushclass (DECL_REAL_CONTEXT (fn
), 2);
5501 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
), /*complain=*/1, NULL_TREE
);
5503 if (DECL_CLASS_SCOPE_P (fn
))
5506 /* Make sure the default argument is reasonable. */
5507 arg
= check_default_argument (type
, arg
);
5512 /* Substitute into all the default arguments for FN. */
5515 tsubst_default_arguments (fn
)
5521 tmpl_args
= DECL_TI_ARGS (fn
);
5523 /* If this function is not yet instantiated, we certainly don't need
5524 its default arguments. */
5525 if (uses_template_parms (tmpl_args
))
5528 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
5530 arg
= TREE_CHAIN (arg
))
5531 if (TREE_PURPOSE (arg
))
5532 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
5534 TREE_PURPOSE (arg
));
5537 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5538 (already computed) substitution of ARGS into TREE_TYPE (T), if
5539 appropriate. Return the result of the substitution. IN_DECL is as
5543 tsubst_decl (t
, args
, type
, in_decl
)
5550 char* saved_filename
;
5553 /* Set the filename and linenumber to improve error-reporting. */
5554 saved_lineno
= lineno
;
5555 saved_filename
= input_filename
;
5556 lineno
= DECL_SOURCE_LINE (t
);
5557 input_filename
= DECL_SOURCE_FILE (t
);
5559 switch (TREE_CODE (t
))
5563 /* We can get here when processing a member template function
5564 of a template class. */
5565 tree decl
= DECL_TEMPLATE_RESULT (t
);
5567 int is_template_template_parm
= DECL_TEMPLATE_TEMPLATE_PARM_P (t
);
5569 if (!is_template_template_parm
)
5571 /* We might already have an instance of this template.
5572 The ARGS are for the surrounding class type, so the
5573 full args contain the tsubst'd args for the context,
5574 plus the innermost args from the template decl. */
5575 tree tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
5576 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
5577 : DECL_TI_ARGS (DECL_RESULT (t
));
5581 full_args
= tsubst_template_arg_vector (tmpl_args
, args
,
5584 /* tsubst_template_arg_vector doesn't copy the vector if
5585 nothing changed. But, *something* should have
5587 my_friendly_assert (full_args
!= tmpl_args
, 0);
5589 spec
= retrieve_specialization (t
, full_args
);
5591 if (spec
!= NULL_TREE
)
5598 /* Make a new template decl. It will be similar to the
5599 original, but will record the current template arguments.
5600 We also create a new function declaration, which is just
5601 like the old one, but points to this new template, rather
5602 than the old one. */
5605 my_friendly_assert (DECL_LANG_SPECIFIC (r
) != 0, 0);
5606 TREE_CHAIN (r
) = NULL_TREE
;
5608 if (is_template_template_parm
)
5610 tree new_decl
= tsubst (decl
, args
, /*complain=*/1, in_decl
);
5611 DECL_RESULT (r
) = new_decl
;
5612 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5617 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, /*complain=*/1,
5618 in_decl
, /*entering_scope=*/1);
5619 DECL_CLASS_CONTEXT (r
)
5620 = tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
,
5621 /*complain=*/1, in_decl
,
5622 /*entering_scope=*/1);
5623 DECL_TEMPLATE_INFO (r
) = build_tree_list (t
, args
);
5625 if (TREE_CODE (decl
) == TYPE_DECL
)
5627 tree new_type
= tsubst (TREE_TYPE (t
), args
,
5628 /*complain=*/1, in_decl
);
5629 TREE_TYPE (r
) = new_type
;
5630 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
5631 DECL_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
5632 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
5636 tree new_decl
= tsubst (decl
, args
, /*complain=*/1, in_decl
);
5637 DECL_RESULT (r
) = new_decl
;
5638 DECL_TI_TEMPLATE (new_decl
) = r
;
5639 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5640 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
5643 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5644 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
5645 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
5647 /* The template parameters for this new template are all the
5648 template parameters for the old template, except the
5649 outermost level of parameters. */
5650 DECL_TEMPLATE_PARMS (r
)
5651 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
5654 if (PRIMARY_TEMPLATE_P (t
))
5655 DECL_PRIMARY_TEMPLATE (r
) = r
;
5657 /* We don't partially instantiate partial specializations. */
5658 if (TREE_CODE (decl
) == TYPE_DECL
)
5661 for (spec
= DECL_TEMPLATE_SPECIALIZATIONS (t
);
5663 spec
= TREE_CHAIN (spec
))
5665 /* It helps to consider example here. Consider:
5676 Now, for example, we are instantiating S<int>::f(U u).
5677 We want to make a template:
5682 It will have a specialization, for the case U = int*, of
5686 void S<int>::f<int*>(int*);
5688 This specialization will be an instantiation of
5689 the specialization given in the declaration of S, with
5690 argument list int*. */
5692 tree fn
= TREE_VALUE (spec
);
5696 if (!DECL_TEMPLATE_SPECIALIZATION (fn
))
5697 /* Instantiations are on the same list, but they're of
5698 no concern to us. */
5701 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
5702 /* A full specialization. There's no need to record
5706 spec_args
= tsubst (DECL_TI_ARGS (fn
), args
,
5707 /*complain=*/1, in_decl
);
5708 new_fn
= tsubst (DECL_RESULT (most_general_template (fn
)),
5709 spec_args
, /*complain=*/1, in_decl
);
5710 DECL_TI_TEMPLATE (new_fn
) = fn
;
5711 register_specialization (new_fn
, r
,
5712 innermost_args (spec_args
));
5715 /* Record this partial instantiation. */
5716 register_specialization (r
, t
,
5717 DECL_TI_ARGS (DECL_RESULT (r
)));
5725 tree argvec
= NULL_TREE
;
5732 /* Nobody should be tsubst'ing into non-template functions. */
5733 my_friendly_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5735 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
5739 /* Allocate template arguments on the momentary obstack,
5740 in case we don't need to keep them. */
5743 /* Calculate the most general template of which R is a
5744 specialization, and the complete set of arguments used to
5746 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
5748 = tsubst_template_arg_vector (DECL_TI_ARGS
5749 (DECL_TEMPLATE_RESULT (gen_tmpl
)),
5750 args
, /*complain=*/1);
5752 /* Check to see if we already have this specialization. */
5753 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5764 /* Here, we deal with the peculiar case:
5766 template <class T> struct S {
5767 template <class U> friend void f();
5769 template <class U> friend void f() {}
5771 template void f<double>();
5773 Here, the ARGS for the instantiation of will be {int,
5774 double}. But, we only need as many ARGS as there are
5775 levels of template parameters in CODE_PATTERN. We are
5776 careful not to get fooled into reducing the ARGS in
5779 template <class T> struct S { template <class U> void f(U); }
5780 template <class T> template <> void S<T>::f(int) {}
5782 which we can spot because the pattern will be a
5783 specialization in this case. */
5784 args_depth
= TMPL_ARGS_DEPTH (args
);
5786 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
5787 if (args_depth
> parms_depth
5788 && !DECL_TEMPLATE_SPECIALIZATION (t
))
5790 my_friendly_assert (DECL_FRIEND_P (t
), 0);
5792 if (parms_depth
> 1)
5796 args
= make_temp_vec (parms_depth
);
5797 for (i
= 0; i
< parms_depth
; ++i
)
5798 TREE_VEC_ELT (args
, i
) =
5799 TREE_VEC_ELT (args
, i
+ (args_depth
- parms_depth
));
5802 args
= TREE_VEC_ELT (args
, args_depth
- parms_depth
);
5807 /* This special case arises when we have something like this:
5809 template <class T> struct S {
5810 friend void f<int>(int, double);
5813 Here, the DECL_TI_TEMPLATE for the friend declaration
5814 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5815 being called from tsubst_friend_function, and we want
5816 only to create a new decl (R) with appropriate types so
5817 that we can call determine_specialization. */
5818 my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t
))
5820 || (TREE_CODE (DECL_TI_TEMPLATE (t
))
5821 == IDENTIFIER_NODE
), 0);
5822 gen_tmpl
= NULL_TREE
;
5825 if (DECL_CLASS_SCOPE_P (t
))
5827 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
5831 ctx
= tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
,
5833 /*entering_scope=*/1);
5840 type
= tsubst (type
, args
, /*complain=*/1, in_decl
);
5842 /* We do NOT check for matching decls pushed separately at this
5843 point, as they may not represent instantiations of this
5844 template, and in any case are considered separate under the
5845 discrete model. Instead, see add_maybe_template. */
5849 DECL_USE_TEMPLATE (r
) = 0;
5850 TREE_TYPE (r
) = type
;
5853 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, /*complain=*/1, t
,
5854 /*entering_scope=*/1);
5855 DECL_CLASS_CONTEXT (r
) = ctx
;
5857 if (member
&& IDENTIFIER_TYPENAME_P (DECL_NAME (r
)))
5858 /* Type-conversion operator. Reconstruct the name, in
5859 case it's the name of one of the template's parameters. */
5860 DECL_NAME (r
) = build_typename_overload (TREE_TYPE (type
));
5862 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
5864 DECL_MAIN_VARIANT (r
) = r
;
5865 DECL_RESULT (r
) = NULL_TREE
;
5867 TREE_STATIC (r
) = 0;
5868 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
5869 DECL_EXTERNAL (r
) = 1;
5870 DECL_INTERFACE_KNOWN (r
) = 0;
5871 DECL_DEFER_OUTPUT (r
) = 0;
5872 TREE_CHAIN (r
) = NULL_TREE
;
5873 DECL_PENDING_INLINE_INFO (r
) = 0;
5874 DECL_PENDING_INLINE_P (r
) = 0;
5877 /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
5878 name. There's no need to do this in the special friend
5879 case mentioned above where GEN_TMPL is NULL. */
5882 DECL_TEMPLATE_INFO (r
)
5883 = tree_cons (gen_tmpl
, argvec
, NULL_TREE
);
5884 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5885 register_specialization (r
, gen_tmpl
, argvec
);
5887 /* Set the mangled name for R. */
5888 if (DECL_DESTRUCTOR_P (t
))
5889 DECL_ASSEMBLER_NAME (r
) = build_destructor_name (ctx
);
5892 /* Instantiations of template functions must be mangled
5893 specially, in order to conform to 14.5.5.1
5894 [temp.over.link]. */
5895 tree tmpl
= DECL_TI_TEMPLATE (t
);
5897 /* TMPL will be NULL if this is a specialization of a
5898 member function of a template class. */
5899 if (name_mangling_version
< 1
5900 || tmpl
== NULL_TREE
5901 || (member
&& !is_member_template (tmpl
)
5902 && !DECL_TEMPLATE_INFO (tmpl
)))
5903 set_mangled_name_for_decl (r
);
5905 set_mangled_name_for_template_decl (r
);
5909 make_decl_rtl (r
, NULL_PTR
, 1);
5911 /* Like grokfndecl. If we don't do this, pushdecl will
5912 mess up our TREE_CHAIN because it doesn't find a
5913 previous decl. Sigh. */
5915 && ! uses_template_parms (r
)
5916 && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
))
5918 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
), r
);
5920 /* We're not supposed to instantiate default arguments
5921 until they are called, for a template. But, for a
5924 template <class T> void f ()
5925 { extern void g(int i = T()); }
5927 we should do the substitution when the template is
5928 instantiated. We handle the member function case in
5929 instantiate_class_template since the default arguments
5930 might refer to other members of the class. */
5932 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
5933 && !uses_template_parms (argvec
))
5934 tsubst_default_arguments (r
);
5937 /* Copy the list of befriending classes. */
5938 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
5940 friends
= &TREE_CHAIN (*friends
))
5942 *friends
= copy_node (*friends
);
5943 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
5944 args
, /*complain=*/1,
5948 if (DECL_CONSTRUCTOR_P (r
))
5950 maybe_retrofit_in_chrg (r
);
5951 grok_ctor_properties (ctx
, r
);
5953 else if (DECL_OVERLOADED_OPERATOR_P (r
))
5954 grok_op_properties (r
, DECL_VIRTUAL_P (r
), DECL_FRIEND_P (r
));
5961 TREE_TYPE (r
) = type
;
5962 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type
), r
);
5964 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
5965 DECL_INITIAL (r
) = TREE_TYPE (r
);
5967 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
5968 /*complain=*/1, in_decl
);
5970 DECL_CONTEXT (r
) = NULL_TREE
;
5971 if (PROMOTE_PROTOTYPES
5972 && (TREE_CODE (type
) == INTEGER_TYPE
5973 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5974 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
5975 DECL_ARG_TYPE (r
) = integer_type_node
;
5977 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
,
5978 /*complain=*/1, TREE_CHAIN (t
));
5986 TREE_TYPE (r
) = type
;
5987 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type
), r
);
5989 /* We don't have to set DECL_CONTEXT here; it is set by
5990 finish_member_declaration. */
5991 DECL_INITIAL (r
) = tsubst_expr (DECL_INITIAL (t
), args
,
5992 /*complain=*/1, in_decl
);
5993 TREE_CHAIN (r
) = NULL_TREE
;
5994 if (TREE_CODE (type
) == VOID_TYPE
)
5995 cp_error_at ("instantiation of `%D' as type void", r
);
6003 = tsubst_copy (DECL_INITIAL (t
), args
, /*complain=*/1, in_decl
);
6004 TREE_CHAIN (r
) = NULL_TREE
;
6009 if (DECL_IMPLICIT_TYPEDEF_P (t
))
6011 /* For an implicit typedef, we just want the implicit
6012 typedef for the tsubst'd type. We've already got the
6013 tsubst'd type, as TYPE, so we just need it's associated
6015 r
= TYPE_NAME (type
);
6018 else if (!DECL_LANG_SPECIFIC (t
))
6020 /* For a template type parameter, we don't have to do
6021 anything special. */
6022 r
= TYPE_NAME (type
);
6036 /* Nobody should be tsubst'ing into non-template variables. */
6037 my_friendly_assert (DECL_LANG_SPECIFIC (t
)
6038 && DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
6040 if (TYPE_P (DECL_CONTEXT (t
)))
6041 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
6043 in_decl
, /*entering_scope=*/1);
6045 /* Subsequent calls to pushdecl will fill this in. */
6048 /* Check to see if we already have this specialization. */
6049 tmpl
= DECL_TI_TEMPLATE (t
);
6050 gen_tmpl
= most_general_template (tmpl
);
6051 argvec
= tsubst (DECL_TI_ARGS (t
), args
, /*complain=*/1, in_decl
);
6053 spec
= retrieve_specialization (gen_tmpl
, argvec
);
6055 spec
= retrieve_local_specialization (gen_tmpl
,
6056 current_function_decl
);
6064 /* This declaration is going to have to be around for a while,
6065 so me make sure it is on a saveable obstack. */
6066 push_obstacks_nochange ();
6067 saveable_allocation ();
6071 TREE_TYPE (r
) = type
;
6072 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type
), r
);
6073 DECL_CONTEXT (r
) = ctx
;
6075 /* Don't try to expand the initializer until someone tries to use
6076 this variable; otherwise we run into circular dependencies. */
6077 DECL_INITIAL (r
) = NULL_TREE
;
6081 DECL_CLASS_CONTEXT (r
) = DECL_CONTEXT (r
);
6083 /* Even if the original location is out of scope, the newly
6084 substituted one is not. */
6085 if (TREE_CODE (r
) == VAR_DECL
)
6086 DECL_DEAD_FOR_LOCAL (r
) = 0;
6088 /* A static data member declaration is always marked external
6089 when it is declared in-class, even if an initializer is
6090 present. We mimic the non-template processing here. */
6092 DECL_EXTERNAL (r
) = 1;
6094 DECL_TEMPLATE_INFO (r
) = tree_cons (tmpl
, argvec
, NULL_TREE
);
6095 SET_DECL_IMPLICIT_INSTANTIATION (r
);
6097 register_specialization (r
, gen_tmpl
, argvec
);
6099 register_local_specialization (r
, gen_tmpl
,
6100 current_function_decl
);
6102 TREE_CHAIN (r
) = NULL_TREE
;
6103 if (TREE_CODE (r
) == VAR_DECL
&& TREE_CODE (type
) == VOID_TYPE
)
6104 cp_error_at ("instantiation of `%D' as type void", r
);
6109 my_friendly_abort (0);
6112 /* Restore the file and line information. */
6113 lineno
= saved_lineno
;
6114 input_filename
= saved_filename
;
6119 /* Substitue into the ARG_TYPES of a function type. */
6122 tsubst_arg_types (arg_types
, args
, complain
, in_decl
)
6128 tree remaining_arg_types
;
6131 if (!arg_types
|| arg_types
== void_list_node
)
6134 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
6135 args
, complain
, in_decl
);
6136 if (remaining_arg_types
== error_mark_node
)
6137 return error_mark_node
;
6139 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
6140 if (type
== error_mark_node
)
6141 return error_mark_node
;
6143 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6144 top-level qualifiers as required. */
6145 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
6147 /* Note that we do not substitute into default arguments here. The
6148 standard mandates that they be instantiated only when needed,
6149 which is done in build_over_call. */
6150 return hash_tree_cons (TREE_PURPOSE (arg_types
), type
,
6151 remaining_arg_types
);
6155 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6156 *not* handle the exception-specification for FNTYPE, because the
6157 initial substitution of explicitly provided template parameters
6158 during argument deduction forbids substitution into the
6159 exception-specification:
6163 All references in the function type of the function template to the
6164 corresponding template parameters are replaced by the specified tem-
6165 plate argument values. If a substitution in a template parameter or
6166 in the function type of the function template results in an invalid
6167 type, type deduction fails. [Note: The equivalent substitution in
6168 exception specifications is done only when the function is instanti-
6169 ated, at which point a program is ill-formed if the substitution
6170 results in an invalid type.] */
6173 tsubst_function_type (t
, args
, complain
, in_decl
)
6183 /* The TYPE_CONTEXT is not used for function/method types. */
6184 my_friendly_assert (TYPE_CONTEXT (t
) == NULL_TREE
, 0);
6186 /* Substitue the return type. */
6187 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
6188 if (return_type
== error_mark_node
)
6189 return error_mark_node
;
6191 /* Substitue the argument types. */
6192 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
,
6194 if (arg_types
== error_mark_node
)
6195 return error_mark_node
;
6197 /* Construct a new type node and return it. */
6198 if (TREE_CODE (t
) == FUNCTION_TYPE
)
6199 fntype
= build_function_type (return_type
, arg_types
);
6202 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
6203 if (! IS_AGGR_TYPE (r
))
6207 Type deduction may fail for any of the following
6210 -- Attempting to create "pointer to member of T" when T
6211 is not a class type. */
6213 cp_error ("creating pointer to member function of non-class type `%T'",
6215 return error_mark_node
;
6218 fntype
= build_cplus_method_type (r
, return_type
, TREE_CHAIN
6221 fntype
= build_qualified_type (fntype
, TYPE_QUALS (t
));
6222 fntype
= build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
6227 /* Substitute into the PARMS of a call-declarator. */
6230 tsubst_call_declarator_parms (parms
, args
, complain
, in_decl
)
6240 if (!parms
|| parms
== void_list_node
)
6243 new_parms
= tsubst_call_declarator_parms (TREE_CHAIN (parms
),
6244 args
, complain
, in_decl
);
6246 /* Figure out the type of this parameter. */
6247 type
= tsubst (TREE_VALUE (parms
), args
, complain
, in_decl
);
6249 /* Figure out the default argument as well. Note that we use
6250 tsubst_expr since the default argument is really an expression. */
6251 defarg
= tsubst_expr (TREE_PURPOSE (parms
), args
, complain
, in_decl
);
6253 /* Chain this parameter on to the front of those we have already
6254 processed. We don't use hash_tree_cons because that function
6255 doesn't check TREE_PARMLIST. */
6256 new_parms
= tree_cons (defarg
, type
, new_parms
);
6258 /* And note that these are parameters. */
6259 TREE_PARMLIST (new_parms
) = 1;
6264 /* Take the tree structure T and replace template parameters used
6265 therein with the argument vector ARGS. IN_DECL is an associated
6266 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6267 An appropriate error message is issued only if COMPLAIN is
6268 non-zero. Note that we must be relatively non-tolerant of
6269 extensions here, in order to preserve conformance; if we allow
6270 substitutions that should not be allowed, we may allow argument
6271 deductions that should not succeed, and therefore report ambiguous
6272 overload situations where there are none. In theory, we could
6273 allow the substitution, but indicate that it should have failed,
6274 and allow our caller to make sure that the right thing happens, but
6275 we don't try to do this yet.
6277 This function is used for dealing with types, decls and the like;
6278 for expressions, use tsubst_expr or tsubst_copy. */
6281 tsubst (t
, args
, complain
, in_decl
)
6288 if (t
== NULL_TREE
|| t
== error_mark_node
6289 || t
== integer_type_node
6290 || t
== void_type_node
6291 || t
== char_type_node
6292 || TREE_CODE (t
) == NAMESPACE_DECL
)
6295 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
6296 type
= IDENTIFIER_TYPE_VALUE (t
);
6298 type
= TREE_TYPE (t
);
6299 if (type
== unknown_type_node
)
6300 my_friendly_abort (42);
6302 if (type
&& TREE_CODE (t
) != FUNCTION_DECL
6303 && TREE_CODE (t
) != TYPENAME_TYPE
6304 && TREE_CODE (t
) != TEMPLATE_DECL
6305 && TREE_CODE (t
) != IDENTIFIER_NODE
6306 && TREE_CODE (t
) != FUNCTION_TYPE
6307 && TREE_CODE (t
) != METHOD_TYPE
)
6308 type
= tsubst (type
, args
, complain
, in_decl
);
6309 if (type
== error_mark_node
)
6310 return error_mark_node
;
6312 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'd')
6313 return tsubst_decl (t
, args
, type
, in_decl
);
6315 switch (TREE_CODE (t
))
6320 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
6321 /*entering_scope=*/0);
6324 case IDENTIFIER_NODE
:
6336 if (t
== integer_type_node
)
6339 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
6340 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
6344 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
6346 max
= tsubst_expr (omax
, args
, complain
, in_decl
);
6347 if (max
== error_mark_node
)
6348 return error_mark_node
;
6350 /* See if we can reduce this expression to something simpler. */
6351 max
= maybe_fold_nontype_arg (max
);
6352 if (!processing_template_decl
&& TREE_READONLY_DECL_P (max
))
6353 max
= decl_constant_value (max
);
6355 if (processing_template_decl
6356 /* When providing explicit arguments to a template
6357 function, but leaving some arguments for subsequent
6358 deduction, MAX may be template-dependent even if we're
6359 not PROCESSING_TEMPLATE_DECL. */
6360 || TREE_CODE (max
) != INTEGER_CST
)
6362 tree itype
= make_node (INTEGER_TYPE
);
6363 TYPE_MIN_VALUE (itype
) = size_zero_node
;
6364 TYPE_MAX_VALUE (itype
) = build_min (MINUS_EXPR
, sizetype
, max
,
6369 if (integer_zerop (omax
))
6371 /* Still allow an explicit array of size zero. */
6373 pedwarn ("creating array with size zero");
6375 else if (integer_zerop (max
) || INT_CST_LT (max
, integer_zero_node
))
6379 Type deduction may fail for any of the following
6382 Attempting to create an array with a size that is
6383 zero or negative. */
6385 cp_error ("creating array with size `%E'", max
);
6387 return error_mark_node
;
6390 max
= fold (build_binary_op (MINUS_EXPR
, max
, integer_one_node
));
6391 return build_index_type (max
);
6394 case TEMPLATE_TYPE_PARM
:
6395 case TEMPLATE_TEMPLATE_PARM
:
6396 case TEMPLATE_PARM_INDEX
:
6404 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
6405 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
6407 idx
= TEMPLATE_TYPE_IDX (t
);
6408 level
= TEMPLATE_TYPE_LEVEL (t
);
6412 idx
= TEMPLATE_PARM_IDX (t
);
6413 level
= TEMPLATE_PARM_LEVEL (t
);
6416 if (TREE_VEC_LENGTH (args
) > 0)
6418 tree arg
= NULL_TREE
;
6420 levels
= TMPL_ARGS_DEPTH (args
);
6421 if (level
<= levels
)
6422 arg
= TMPL_ARG (args
, level
, idx
);
6424 if (arg
== error_mark_node
)
6425 return error_mark_node
;
6426 else if (arg
!= NULL_TREE
)
6428 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
6430 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg
))
6432 return cp_build_qualified_type_real
6433 (arg
, CP_TYPE_QUALS (arg
) | CP_TYPE_QUALS (t
),
6436 else if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
6438 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
6440 /* We are processing a type constructed from
6441 a template template parameter */
6442 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
6443 args
, complain
, in_decl
);
6444 if (argvec
== error_mark_node
)
6445 return error_mark_node
;
6447 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6448 we are resolving nested-types in the signature of
6449 a member function templates.
6450 Otherwise ARG is a TEMPLATE_DECL and is the real
6451 template to be instantiated. */
6452 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
6453 arg
= TYPE_NAME (arg
);
6455 r
= lookup_template_class (DECL_NAME (arg
),
6458 /*entering_scope=*/0);
6459 return cp_build_qualified_type_real (r
,
6464 /* We are processing a template argument list. */
6472 my_friendly_abort (981018);
6475 /* This can happen during the attempted tsubst'ing in
6476 unify. This means that we don't yet have any information
6477 about the template parameter in question. */
6480 /* If we get here, we must have been looking at a parm for a
6481 more deeply nested template. Make a new version of this
6482 template parameter, but with a lower level. */
6483 switch (TREE_CODE (t
))
6485 case TEMPLATE_TYPE_PARM
:
6486 case TEMPLATE_TEMPLATE_PARM
:
6488 TEMPLATE_TYPE_PARM_INDEX (r
)
6489 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
6491 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
6492 TYPE_MAIN_VARIANT (r
) = r
;
6493 TYPE_POINTER_TO (r
) = NULL_TREE
;
6494 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
6496 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
6497 && TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
6499 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
6501 if (argvec
== error_mark_node
)
6502 return error_mark_node
;
6504 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
6505 = tree_cons (TYPE_NAME (t
), argvec
, NULL_TREE
);
6509 case TEMPLATE_PARM_INDEX
:
6510 r
= reduce_template_parm_level (t
, type
, levels
);
6514 my_friendly_abort (0);
6522 tree purpose
, value
, chain
, result
;
6524 if (t
== void_list_node
)
6527 purpose
= TREE_PURPOSE (t
);
6530 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
6531 if (purpose
== error_mark_node
)
6532 return error_mark_node
;
6534 value
= TREE_VALUE (t
);
6537 value
= tsubst (value
, args
, complain
, in_decl
);
6538 if (value
== error_mark_node
)
6539 return error_mark_node
;
6541 chain
= TREE_CHAIN (t
);
6542 if (chain
&& chain
!= void_type_node
)
6544 chain
= tsubst (chain
, args
, complain
, in_decl
);
6545 if (chain
== error_mark_node
)
6546 return error_mark_node
;
6548 if (purpose
== TREE_PURPOSE (t
)
6549 && value
== TREE_VALUE (t
)
6550 && chain
== TREE_CHAIN (t
))
6552 result
= hash_tree_cons (purpose
, value
, chain
);
6553 TREE_PARMLIST (result
) = TREE_PARMLIST (t
);
6557 if (type
!= NULL_TREE
)
6559 /* A binfo node. We always need to make a copy, of the node
6560 itself and of its BINFO_BASETYPES. */
6564 /* Make sure type isn't a typedef copy. */
6565 type
= BINFO_TYPE (TYPE_BINFO (type
));
6567 TREE_TYPE (t
) = complete_type (type
);
6568 if (IS_AGGR_TYPE (type
))
6570 BINFO_VTABLE (t
) = TYPE_BINFO_VTABLE (type
);
6571 BINFO_VIRTUALS (t
) = TYPE_BINFO_VIRTUALS (type
);
6572 if (TYPE_BINFO_BASETYPES (type
) != NULL_TREE
)
6573 BINFO_BASETYPES (t
) = copy_node (TYPE_BINFO_BASETYPES (type
));
6578 /* Otherwise, a vector of template arguments. */
6579 return tsubst_template_arg_vector (t
, args
, complain
);
6582 case REFERENCE_TYPE
:
6584 enum tree_code code
;
6586 if (type
== TREE_TYPE (t
))
6589 code
= TREE_CODE (t
);
6594 Type deduction may fail for any of the following
6597 -- Attempting to create a pointer to reference type.
6598 -- Attempting to create a reference to a reference type or
6599 a reference to void. */
6600 if (TREE_CODE (type
) == REFERENCE_TYPE
6601 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
6603 static int last_line
= 0;
6604 static char* last_file
= 0;
6606 /* We keep track of the last time we issued this error
6607 message to avoid spewing a ton of messages during a
6608 single bad template instantiation. */
6609 if (complain
&& (last_line
!= lineno
||
6610 last_file
!= input_filename
))
6612 if (TREE_CODE (type
) == VOID_TYPE
)
6613 cp_error ("forming reference to void");
6615 cp_error ("forming %s to reference type `%T'",
6616 (code
== POINTER_TYPE
) ? "pointer" : "reference",
6619 last_file
= input_filename
;
6622 return error_mark_node
;
6624 else if (code
== POINTER_TYPE
)
6625 r
= build_pointer_type (type
);
6627 r
= build_reference_type (type
);
6628 r
= cp_build_qualified_type_real (r
, TYPE_QUALS (t
), complain
);
6630 /* Will this ever be needed for TYPE_..._TO values? */
6636 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
6637 if (r
== error_mark_node
|| !IS_AGGR_TYPE (r
))
6641 Type deduction may fail for any of the following
6644 -- Attempting to create "pointer to member of T" when T
6645 is not a class type. */
6647 cp_error ("creating pointer to member of non-class type `%T'",
6649 return error_mark_node
;
6651 return build_offset_type (r
, type
);
6659 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
6660 if (fntype
== error_mark_node
)
6661 return error_mark_node
;
6663 /* Substitue the exception specification. */
6664 raises
= TYPE_RAISES_EXCEPTIONS (t
);
6667 tree list
= NULL_TREE
;
6669 if (! TREE_VALUE (raises
))
6672 for (; raises
!= NULL_TREE
; raises
= TREE_CHAIN (raises
))
6674 tree spec
= TREE_VALUE (raises
);
6676 spec
= tsubst (spec
, args
, complain
, in_decl
);
6677 if (spec
== error_mark_node
)
6679 list
= add_exception_specifier (list
, spec
, complain
);
6681 fntype
= build_exception_variant (fntype
, list
);
6687 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
6688 if (domain
== error_mark_node
)
6689 return error_mark_node
;
6691 /* As an optimization, we avoid regenerating the array type if
6692 it will obviously be the same as T. */
6693 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
6696 /* These checks should match the ones in grokdeclarator.
6700 The deduction may fail for any of the following reasons:
6702 -- Attempting to create an array with an element type that
6703 is void, a function type, or a reference type. */
6704 if (TREE_CODE (type
) == VOID_TYPE
6705 || TREE_CODE (type
) == FUNCTION_TYPE
6706 || TREE_CODE (type
) == REFERENCE_TYPE
)
6709 cp_error ("creating array of `%T'", type
);
6710 return error_mark_node
;
6713 r
= build_cplus_array_type (type
, domain
);
6720 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6722 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
,
6725 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6726 return error_mark_node
;
6728 return fold (build (TREE_CODE (t
), TREE_TYPE (t
), e1
, e2
));
6734 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6736 if (e
== error_mark_node
)
6737 return error_mark_node
;
6739 return fold (build (TREE_CODE (t
), TREE_TYPE (t
), e
));
6744 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
6745 in_decl
, /*entering_scope=*/1);
6746 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
6749 if (ctx
== error_mark_node
|| f
== error_mark_node
)
6750 return error_mark_node
;
6752 if (!IS_AGGR_TYPE (ctx
))
6755 cp_error ("`%T' is not a class, struct, or union type",
6757 return error_mark_node
;
6759 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
6761 /* Normally, make_typename_type does not require that the CTX
6762 have complete type in order to allow things like:
6764 template <class T> struct S { typename S<T>::X Y; };
6766 But, such constructs have already been resolved by this
6767 point, so here CTX really should have complete type, unless
6768 it's a partial instantiation. */
6769 ctx
= complete_type (ctx
);
6770 if (!TYPE_SIZE (ctx
))
6773 incomplete_type_error (NULL_TREE
, ctx
);
6774 return error_mark_node
;
6778 f
= make_typename_type (ctx
, f
);
6779 if (f
== error_mark_node
)
6781 return cp_build_qualified_type_real (f
,
6783 | CP_TYPE_QUALS (t
),
6789 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6791 if (e
== error_mark_node
)
6792 return error_mark_node
;
6793 return make_pointer_declarator (type
, e
);
6798 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6800 if (e
== error_mark_node
)
6801 return error_mark_node
;
6802 return make_reference_declarator (type
, e
);
6807 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6809 tree e2
= tsubst_expr (TREE_OPERAND (t
, 1), args
, complain
,
6811 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6812 return error_mark_node
;
6814 return build_parse_node (ARRAY_REF
, e1
, e2
, tsubst_expr
);
6819 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6821 tree e2
= (tsubst_call_declarator_parms
6822 (CALL_DECLARATOR_PARMS (t
), args
, complain
, in_decl
));
6823 tree e3
= tsubst (CALL_DECLARATOR_EXCEPTION_SPEC (t
), args
,
6826 if (e1
== error_mark_node
|| e2
== error_mark_node
6827 || e3
== error_mark_node
)
6828 return error_mark_node
;
6830 return make_call_declarator (e1
, e2
, CALL_DECLARATOR_QUALS (t
), e3
);
6835 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6837 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
6838 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6839 return error_mark_node
;
6841 return build_parse_node (TREE_CODE (t
), e1
, e2
);
6846 tree e1
= tsubst_expr (TYPE_FIELDS (t
), args
, complain
,
6848 if (e1
== error_mark_node
)
6849 return error_mark_node
;
6851 return TREE_TYPE (e1
);
6855 sorry ("use of `%s' in template",
6856 tree_code_name
[(int) TREE_CODE (t
)]);
6857 return error_mark_node
;
6861 /* Like tsubst, but deals with expressions. This function just replaces
6862 template parms; to finish processing the resultant expression, use
6866 tsubst_copy (t
, args
, complain
, in_decl
)
6871 enum tree_code code
;
6874 if (t
== NULL_TREE
|| t
== error_mark_node
)
6877 code
= TREE_CODE (t
);
6882 return do_identifier (DECL_NAME (t
), 0, NULL_TREE
);
6889 if (!DECL_CONTEXT (t
))
6890 /* This is a global enumeration constant. */
6893 /* Unfortunately, we cannot just call lookup_name here.
6896 template <int I> int f() {
6898 struct S { void g() { E e = a; } };
6901 When we instantiate f<7>::S::g(), say, lookup_name is not
6902 clever enough to find f<7>::a. */
6904 = tsubst_aggr_type (TREE_TYPE (t
), args
, complain
, in_decl
,
6905 /*entering_scope=*/0);
6907 for (v
= TYPE_VALUES (enum_type
);
6910 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
6911 return TREE_VALUE (v
);
6913 /* We didn't find the name. That should never happen; if
6914 name-lookup found it during preliminary parsing, we
6915 should find it again here during instantiation. */
6916 my_friendly_abort (0);
6921 if (DECL_CONTEXT (t
))
6925 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
6926 /*entering_scope=*/1);
6927 if (ctx
!= DECL_CONTEXT (t
))
6928 return lookup_field (ctx
, DECL_NAME (t
), 0, 0);
6934 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
6935 t
= tsubst (t
, args
, complain
, in_decl
);
6940 if (is_member_template (t
))
6941 return tsubst (t
, args
, complain
, in_decl
);
6947 /* We must tsbust into a LOOKUP_EXPR in case the names to
6948 which it refers is a conversion operator; in that case the
6949 name will change. We avoid making unnecessary copies,
6952 tree id
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
6954 if (id
!= TREE_OPERAND (t
, 0))
6956 r
= build_nt (LOOKUP_EXPR
, id
);
6957 LOOKUP_EXPR_GLOBAL (r
) = LOOKUP_EXPR_GLOBAL (t
);
6965 case REINTERPRET_CAST_EXPR
:
6966 case CONST_CAST_EXPR
:
6967 case STATIC_CAST_EXPR
:
6968 case DYNAMIC_CAST_EXPR
:
6971 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
6972 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
6975 case PREDECREMENT_EXPR
:
6976 case PREINCREMENT_EXPR
:
6977 case POSTDECREMENT_EXPR
:
6978 case POSTINCREMENT_EXPR
:
6980 case TRUTH_NOT_EXPR
:
6983 case CONVERT_EXPR
: /* Unary + */
6990 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
6991 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
6996 case TRUNC_DIV_EXPR
:
6998 case FLOOR_DIV_EXPR
:
6999 case ROUND_DIV_EXPR
:
7000 case EXACT_DIV_EXPR
:
7002 case BIT_ANDTC_EXPR
:
7005 case TRUNC_MOD_EXPR
:
7006 case FLOOR_MOD_EXPR
:
7007 case TRUTH_ANDIF_EXPR
:
7008 case TRUTH_ORIF_EXPR
:
7009 case TRUTH_AND_EXPR
:
7030 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
7031 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
7035 tree fn
= TREE_OPERAND (t
, 0);
7036 if (is_overloaded_fn (fn
))
7037 fn
= tsubst_copy (get_first_fn (fn
), args
, complain
, in_decl
);
7039 /* Sometimes FN is a LOOKUP_EXPR. */
7040 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
7042 (code
, fn
, tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
,
7047 case METHOD_CALL_EXPR
:
7049 tree name
= TREE_OPERAND (t
, 0);
7050 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
7052 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
7054 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
7056 else if (TREE_CODE (name
) == SCOPE_REF
7057 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
7059 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
7061 name
= TREE_OPERAND (name
, 1);
7062 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
7064 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
7065 name
= build_nt (SCOPE_REF
, base
, name
);
7068 name
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
7070 (code
, name
, tsubst_copy (TREE_OPERAND (t
, 1), args
,
7072 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
),
7077 /* This processing should really occur in tsubst_expr, However,
7078 tsubst_expr does not recurse into expressions, since it
7079 assumes that there aren't any statements inside them.
7080 Instead, it simply calls build_expr_from_tree. So, we need
7081 to expand the STMT_EXPR here. */
7082 if (!processing_template_decl
)
7084 tree rtl_expr
= begin_stmt_expr ();
7085 tsubst_expr (STMT_EXPR_STMT (t
), args
,
7087 return finish_stmt_expr (rtl_expr
);
7094 case PSEUDO_DTOR_EXPR
:
7097 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
7098 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
7099 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
7106 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
7107 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
7108 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
7109 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
7116 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
7117 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
7118 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
7119 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
7123 case TEMPLATE_ID_EXPR
:
7125 /* Substituted template arguments */
7126 tree targs
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
,
7129 if (targs
&& TREE_CODE (targs
) == TREE_LIST
)
7132 for (chain
= targs
; chain
; chain
= TREE_CHAIN (chain
))
7133 TREE_VALUE (chain
) = maybe_fold_nontype_arg (TREE_VALUE (chain
));
7138 for (i
= 0; i
< TREE_VEC_LENGTH (targs
); ++i
)
7139 TREE_VEC_ELT (targs
, i
)
7140 = maybe_fold_nontype_arg (TREE_VEC_ELT (targs
, i
));
7143 return lookup_template_function
7144 (tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
), targs
);
7149 tree purpose
, value
, chain
;
7151 if (t
== void_list_node
)
7154 purpose
= TREE_PURPOSE (t
);
7156 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
7157 value
= TREE_VALUE (t
);
7159 value
= tsubst_copy (value
, args
, complain
, in_decl
);
7160 chain
= TREE_CHAIN (t
);
7161 if (chain
&& chain
!= void_type_node
)
7162 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
7163 if (purpose
== TREE_PURPOSE (t
)
7164 && value
== TREE_VALUE (t
)
7165 && chain
== TREE_CHAIN (t
))
7167 return tree_cons (purpose
, value
, chain
);
7174 case TEMPLATE_TYPE_PARM
:
7175 case TEMPLATE_TEMPLATE_PARM
:
7176 case TEMPLATE_PARM_INDEX
:
7178 case REFERENCE_TYPE
:
7185 return tsubst (t
, args
, complain
, in_decl
);
7187 case IDENTIFIER_NODE
:
7188 if (IDENTIFIER_TYPENAME_P (t
)
7189 /* Make sure it's not just a variable named `__opr', for instance,
7190 which can occur in some existing code. */
7192 return build_typename_overload
7193 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
7200 (CONSTRUCTOR
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
7201 NULL_TREE
, tsubst_copy (CONSTRUCTOR_ELTS (t
), args
,
7202 complain
, in_decl
));
7203 TREE_HAS_CONSTRUCTOR (r
) = TREE_HAS_CONSTRUCTOR (t
);
7208 return build_va_arg (tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
7210 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
7217 /* Like tsubst_copy, but also does semantic processing. */
7220 tsubst_expr (t
, args
, complain
, in_decl
)
7227 if (t
== NULL_TREE
|| t
== error_mark_node
)
7230 if (processing_template_decl
)
7231 return tsubst_copy (t
, args
, complain
, in_decl
);
7233 switch (TREE_CODE (t
))
7237 finish_named_return_value
7238 (TREE_OPERAND (t
, 0),
7239 tsubst_expr (TREE_OPERAND (t
, 1), args
, /*complain=*/1, in_decl
));
7240 tsubst_expr (TREE_CHAIN (t
), args
, complain
, in_decl
);
7243 case CTOR_INITIALIZER
:
7245 current_member_init_list
7246 = tsubst_expr_values (TREE_OPERAND (t
, 0), args
);
7247 current_base_init_list
7248 = tsubst_expr_values (TREE_OPERAND (t
, 1), args
);
7250 tsubst_expr (TREE_CHAIN (t
), args
, complain
, in_decl
);
7255 finish_return_stmt (tsubst_expr (RETURN_EXPR (t
),
7256 args
, complain
, in_decl
));
7261 finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t
),
7262 args
, complain
, in_decl
));
7267 int i
= suspend_momentary ();
7272 decl
= DECL_STMT_DECL (t
);
7273 if (TREE_CODE (decl
) == LABEL_DECL
)
7274 finish_label_decl (DECL_NAME (decl
));
7277 init
= DECL_INITIAL (decl
);
7278 decl
= tsubst (decl
, args
, complain
, in_decl
);
7279 init
= tsubst_expr (init
, args
, complain
, in_decl
);
7281 DECL_INITIAL (decl
) = error_mark_node
;
7282 /* By marking the declaration as instantiated, we avoid
7283 trying to instantiate it. Since instantiate_decl can't
7284 handle local variables, and since we've already done
7285 all that needs to be done, that's the right thing to
7287 if (TREE_CODE (decl
) == VAR_DECL
)
7288 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
7289 maybe_push_decl (decl
);
7290 cp_finish_decl (decl
, init
, NULL_TREE
, 0, 0);
7292 resume_momentary (i
);
7301 stmt
= begin_for_stmt ();
7302 for (tmp
= FOR_INIT_STMT (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
7303 tsubst_expr (tmp
, args
, complain
, in_decl
);
7304 finish_for_init_stmt (stmt
);
7305 finish_for_cond (tsubst_expr (FOR_COND (t
), args
,
7308 tmp
= tsubst_expr (FOR_EXPR (t
), args
, complain
, in_decl
);
7309 finish_for_expr (tmp
, stmt
);
7310 tsubst_expr (FOR_BODY (t
), args
, complain
, in_decl
);
7311 finish_for_stmt (tmp
, stmt
);
7318 stmt
= begin_while_stmt ();
7319 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t
),
7320 args
, complain
, in_decl
),
7322 tsubst_expr (WHILE_BODY (t
), args
, complain
, in_decl
);
7323 finish_while_stmt (stmt
);
7330 stmt
= begin_do_stmt ();
7331 tsubst_expr (DO_BODY (t
), args
, complain
, in_decl
);
7332 finish_do_body (stmt
);
7333 finish_do_stmt (tsubst_expr (DO_COND (t
), args
,
7344 stmt
= begin_if_stmt ();
7345 finish_if_stmt_cond (tsubst_expr (IF_COND (t
),
7346 args
, complain
, in_decl
),
7349 if (tmp
= THEN_CLAUSE (t
), tmp
)
7351 tsubst_expr (tmp
, args
, complain
, in_decl
);
7352 finish_then_clause (stmt
);
7355 if (tmp
= ELSE_CLAUSE (t
), tmp
)
7357 begin_else_clause ();
7358 tsubst_expr (tmp
, args
, complain
, in_decl
);
7359 finish_else_clause (stmt
);
7371 stmt
= begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
));
7372 for (substmt
= COMPOUND_BODY (t
);
7373 substmt
!= NULL_TREE
;
7374 substmt
= TREE_CHAIN (substmt
))
7375 tsubst_expr (substmt
, args
, complain
, in_decl
);
7376 return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
), stmt
);
7382 finish_break_stmt ();
7387 finish_continue_stmt ();
7395 stmt
= begin_switch_stmt ();
7396 val
= tsubst_expr (SWITCH_COND (t
), args
, complain
, in_decl
);
7397 finish_switch_cond (val
, stmt
);
7398 tsubst_expr (SWITCH_BODY (t
), args
, complain
, in_decl
);
7399 finish_switch_stmt (val
, stmt
);
7405 finish_case_label (tsubst_expr (CASE_LOW (t
), args
, complain
, in_decl
),
7406 tsubst_expr (CASE_HIGH (t
), args
, complain
, in_decl
));
7410 lineno
= STMT_LINENO (t
);
7411 finish_label_stmt (DECL_NAME (LABEL_STMT_LABEL (t
)));
7416 t
= GOTO_DESTINATION (t
);
7417 if (TREE_CODE (t
) != LABEL_DECL
)
7418 /* Computed goto's must be tsubst'd into. On the other hand,
7419 non-computed gotos must not be; the identifier in question
7420 will have no binding. */
7421 t
= tsubst_expr (t
, args
, complain
, in_decl
);
7424 finish_goto_stmt (t
);
7429 finish_asm_stmt (ASM_CV_QUAL (t
),
7430 tsubst_expr (ASM_STRING (t
), args
, complain
, in_decl
),
7431 tsubst_expr (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
7432 tsubst_expr (ASM_INPUTS (t
), args
, complain
, in_decl
),
7433 tsubst_expr (ASM_CLOBBERS (t
), args
, complain
,
7441 stmt
= begin_try_block ();
7442 tsubst_expr (TRY_STMTS (t
), args
, complain
, in_decl
);
7443 finish_cleanup_try_block (stmt
);
7444 finish_cleanup (tsubst_expr (TRY_HANDLERS (t
), args
,
7452 if (FN_TRY_BLOCK_P (t
))
7453 stmt
= begin_function_try_block ();
7455 stmt
= begin_try_block ();
7457 tsubst_expr (TRY_STMTS (t
), args
, complain
, in_decl
);
7459 if (FN_TRY_BLOCK_P (t
))
7460 finish_function_try_block (stmt
);
7462 finish_try_block (stmt
);
7464 handler
= TRY_HANDLERS (t
);
7465 for (; handler
; handler
= TREE_CHAIN (handler
))
7466 tsubst_expr (handler
, args
, complain
, in_decl
);
7467 if (FN_TRY_BLOCK_P (t
))
7468 finish_function_handler_sequence (stmt
);
7470 finish_handler_sequence (stmt
);
7480 stmt
= begin_handler ();
7481 if (HANDLER_PARMS (t
))
7483 decl
= DECL_STMT_DECL (HANDLER_PARMS (t
));
7484 decl
= tsubst (decl
, args
, complain
, in_decl
);
7488 blocks
= finish_handler_parms (decl
, stmt
);
7489 tsubst_expr (HANDLER_BODY (t
), args
, complain
, in_decl
);
7490 finish_handler (blocks
, stmt
);
7497 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
7498 tsubst (t
, args
, complain
, NULL_TREE
);
7502 return build_expr_from_tree (tsubst_copy (t
, args
, complain
, in_decl
));
7507 /* Instantiate the indicated variable or function template TMPL with
7508 the template arguments in TARG_PTR. */
7511 instantiate_template (tmpl
, targ_ptr
)
7512 tree tmpl
, targ_ptr
;
7518 struct obstack
*old_fmp_obstack
;
7519 extern struct obstack
*function_maybepermanent_obstack
;
7522 if (tmpl
== error_mark_node
)
7523 return error_mark_node
;
7525 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 283);
7527 /* Check to see if we already have this specialization. */
7528 spec
= retrieve_specialization (tmpl
, targ_ptr
);
7529 if (spec
!= NULL_TREE
)
7532 if (DECL_TEMPLATE_INFO (tmpl
))
7534 /* The TMPL is a partial instantiation. To get a full set of
7535 arguments we must add the arguments used to perform the
7536 partial instantiation. */
7537 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
7539 gen_tmpl
= most_general_template (tmpl
);
7541 /* Check to see if we already have this specialization. */
7542 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
);
7543 if (spec
!= NULL_TREE
)
7549 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7550 old_fmp_obstack
= function_maybepermanent_obstack
;
7551 function_maybepermanent_obstack
= &permanent_obstack
;
7553 len
= DECL_NTPARMS (gen_tmpl
);
7554 inner_args
= innermost_args (targ_ptr
);
7558 tree t
= TREE_VEC_ELT (inner_args
, i
);
7559 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
7561 tree nt
= target_type (t
);
7562 if (IS_AGGR_TYPE (nt
) && decl_function_context (TYPE_MAIN_DECL (nt
)))
7564 cp_error ("type `%T' composed from a local class is not a valid template-argument", t
);
7565 cp_error (" trying to instantiate `%D'", gen_tmpl
);
7566 fndecl
= error_mark_node
;
7572 /* substitute template parameters */
7573 fndecl
= tsubst (DECL_RESULT (gen_tmpl
), targ_ptr
, /*complain=*/1, gen_tmpl
);
7574 /* The DECL_TI_TEMPLATE should always be the immediate parent
7575 template, not the most general template. */
7576 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
7578 if (flag_external_templates
)
7579 add_pending_template (fndecl
);
7582 function_maybepermanent_obstack
= old_fmp_obstack
;
7588 /* Push the name of the class template into the scope of the instantiation. */
7591 overload_template_name (type
)
7594 tree id
= DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
));
7597 if (IDENTIFIER_CLASS_VALUE (id
)
7598 && TREE_TYPE (IDENTIFIER_CLASS_VALUE (id
)) == type
)
7601 decl
= build_decl (TYPE_DECL
, id
, type
);
7602 SET_DECL_ARTIFICIAL (decl
);
7603 pushdecl_class_level (decl
);
7606 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
7607 arguments that are being used when calling it. TARGS is a vector
7608 into which the deduced template arguments are placed.
7610 Return zero for success, 2 for an incomplete match that doesn't resolve
7611 all the types, and 1 for complete failure. An error message will be
7612 printed only for an incomplete match.
7614 If FN is a conversion operator, RETURN_TYPE is the type desired as
7615 the result of the conversion operator.
7617 TPARMS is a vector of template parameters.
7619 The EXPLICIT_TARGS are explicit template arguments provided via a
7622 The parameter STRICT is one of:
7625 We are deducing arguments for a function call, as in
7629 We are deducing arguments for a conversion function, as in
7633 We are deducing arguments when calculating the partial
7634 ordering between specializations of function or class
7635 templates, as in [temp.func.order] and [temp.class.order],
7636 when doing an explicit instantiation as in [temp.explicit],
7637 when determining an explicit specialization as in
7638 [temp.expl.spec], or when taking the address of a function
7639 template, as in [temp.deduct.funcaddr].
7641 The other arguments are as for type_unification. */
7644 fn_type_unification (fn
, explicit_targs
, targs
, args
, return_type
,
7646 tree fn
, explicit_targs
, targs
, args
, return_type
;
7647 unification_kind_t strict
;
7653 my_friendly_assert (TREE_CODE (fn
) == TEMPLATE_DECL
, 0);
7655 fntype
= TREE_TYPE (fn
);
7660 The specified template arguments must match the template
7661 parameters in kind (i.e., type, nontype, template), and there
7662 must not be more arguments than there are parameters;
7663 otherwise type deduction fails.
7665 Nontype arguments must match the types of the corresponding
7666 nontype template parameters, or must be convertible to the
7667 types of the corresponding nontype parameters as specified in
7668 _temp.arg.nontype_, otherwise type deduction fails.
7670 All references in the function type of the function template
7671 to the corresponding template parameters are replaced by the
7672 specified template argument values. If a substitution in a
7673 template parameter or in the function type of the function
7674 template results in an invalid type, type deduction fails. */
7676 tree converted_args
;
7679 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
7680 explicit_targs
, NULL_TREE
, /*complain=*/0,
7681 /*require_all_arguments=*/0));
7682 if (converted_args
== error_mark_node
)
7685 fntype
= tsubst (fntype
, converted_args
, /*complain=*/0, NULL_TREE
);
7686 if (fntype
== error_mark_node
)
7689 /* Place the explicitly specified arguments in TARGS. */
7690 for (i
= 0; i
< TREE_VEC_LENGTH (targs
); i
++)
7691 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (converted_args
, i
);
7694 parms
= TYPE_ARG_TYPES (fntype
);
7696 if (DECL_CONV_FN_P (fn
))
7698 /* This is a template conversion operator. Use the return types
7699 as well as the argument types. We use it instead of 'this', since
7700 we could be comparing conversions from different classes. */
7701 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
),
7702 TREE_CHAIN (parms
));
7703 args
= tree_cons (NULL_TREE
, return_type
, TREE_CHAIN (args
));
7706 /* We allow incomplete unification without an error message here
7707 because the standard doesn't seem to explicitly prohibit it. Our
7708 callers must be ready to deal with unification failures in any
7710 result
= type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
7711 targs
, parms
, args
, /*subr=*/0,
7712 strict
, /*allow_incomplete*/1);
7715 /* All is well so far. Now, check:
7719 When all template arguments have been deduced, all uses of
7720 template parameters in nondeduced contexts are replaced with
7721 the corresponding deduced argument values. If the
7722 substitution results in an invalid type, as described above,
7723 type deduction fails. */
7724 if (tsubst (TREE_TYPE (fn
), targs
, /*complain=*/0, NULL_TREE
)
7731 /* Adjust types before performing type deduction, as described in
7732 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
7733 sections are symmetric. PARM is the type of a function parameter
7734 or the return type of the conversion function. ARG is the type of
7735 the argument passed to the call, or the type of the value
7736 intialized with the result of the conversion function. */
7739 maybe_adjust_types_for_deduction (strict
, parm
, arg
)
7740 unification_kind_t strict
;
7751 /* Swap PARM and ARG throughout the remainder of this
7752 function; the handling is precisely symmetric since PARM
7753 will initialize ARG rather than vice versa. */
7761 /* There is nothing to do in this case. */
7765 my_friendly_abort (0);
7768 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
7770 /* [temp.deduct.call]
7772 If P is not a reference type:
7774 --If A is an array type, the pointer type produced by the
7775 array-to-pointer standard conversion (_conv.array_) is
7776 used in place of A for type deduction; otherwise,
7778 --If A is a function type, the pointer type produced by
7779 the function-to-pointer standard conversion
7780 (_conv.func_) is used in place of A for type deduction;
7783 --If A is a cv-qualified type, the top level
7784 cv-qualifiers of A's type are ignored for type
7786 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
7787 *arg
= build_pointer_type (TREE_TYPE (*arg
));
7788 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
7789 *arg
= build_pointer_type (*arg
);
7791 *arg
= TYPE_MAIN_VARIANT (*arg
);
7794 /* [temp.deduct.call]
7796 If P is a cv-qualified type, the top level cv-qualifiers
7797 of P's type are ignored for type deduction. If P is a
7798 reference type, the type referred to by P is used for
7800 *parm
= TYPE_MAIN_VARIANT (*parm
);
7801 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
7802 *parm
= TREE_TYPE (*parm
);
7805 /* Like type_unfication.
7807 If SUBR is 1, we're being called recursively (to unify the
7808 arguments of a function or method parameter of a function
7812 type_unification_real (tparms
, targs
, parms
, args
, subr
,
7813 strict
, allow_incomplete
)
7814 tree tparms
, targs
, parms
, args
;
7816 unification_kind_t strict
;
7817 int allow_incomplete
;
7821 int ntparms
= TREE_VEC_LENGTH (tparms
);
7824 my_friendly_assert (TREE_CODE (tparms
) == TREE_VEC
, 289);
7825 my_friendly_assert (parms
== NULL_TREE
7826 || TREE_CODE (parms
) == TREE_LIST
, 290);
7827 /* ARGS could be NULL (via a call from parse.y to
7828 build_x_function_call). */
7830 my_friendly_assert (TREE_CODE (args
) == TREE_LIST
, 291);
7831 my_friendly_assert (ntparms
> 0, 292);
7836 sub_strict
= UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_DERIVED
;
7840 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
7844 sub_strict
= UNIFY_ALLOW_NONE
;
7848 my_friendly_abort (0);
7852 && parms
!= void_list_node
7854 && args
!= void_list_node
)
7856 parm
= TREE_VALUE (parms
);
7857 parms
= TREE_CHAIN (parms
);
7858 arg
= TREE_VALUE (args
);
7859 args
= TREE_CHAIN (args
);
7861 if (arg
== error_mark_node
)
7863 if (arg
== unknown_type_node
)
7864 /* We can't deduce anything from this, but we might get all the
7865 template args from other function args. */
7868 /* Conversions will be performed on a function argument that
7869 corresponds with a function parameter that contains only
7870 non-deducible template parameters and explicitly specified
7871 template parameters. */
7872 if (! uses_template_parms (parm
))
7876 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7877 type
= TREE_TYPE (arg
);
7884 if (strict
== DEDUCE_EXACT
)
7886 if (same_type_p (parm
, type
))
7890 /* It might work; we shouldn't check now, because we might
7891 get into infinite recursion. Overload resolution will
7898 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7900 my_friendly_assert (TREE_TYPE (arg
) != NULL_TREE
, 293);
7901 if (type_unknown_p (arg
))
7903 /* [temp.deduct.type] A template-argument can be deduced from
7904 a pointer to function or pointer to member function
7905 argument if the set of overloaded functions does not
7906 contain function templates and at most one of a set of
7907 overloaded functions provides a unique match. */
7909 if (resolve_overloaded_unification
7910 (tparms
, targs
, parm
, arg
, strict
, sub_strict
)
7915 arg
= TREE_TYPE (arg
);
7919 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7921 switch (unify (tparms
, targs
, parm
, arg
, sub_strict
))
7929 /* Fail if we've reached the end of the parm list, and more args
7930 are present, and the parm list isn't variadic. */
7931 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
7933 /* Fail if parms are left and they don't have default values. */
7935 && parms
!= void_list_node
7936 && TREE_PURPOSE (parms
) == NULL_TREE
)
7939 for (i
= 0; i
< ntparms
; i
++)
7940 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
7942 if (!allow_incomplete
)
7943 error ("incomplete type unification");
7949 /* Subroutine of type_unification_real. Args are like the variables at the
7950 call site. ARG is an overloaded function (or template-id); we try
7951 deducing template args from each of the overloads, and if only one
7952 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
7955 resolve_overloaded_unification (tparms
, targs
, parm
, arg
, strict
,
7957 tree tparms
, targs
, parm
, arg
;
7958 unification_kind_t strict
;
7961 tree tempargs
= copy_node (targs
);
7964 if (TREE_CODE (arg
) == ADDR_EXPR
)
7965 arg
= TREE_OPERAND (arg
, 0);
7967 if (TREE_CODE (arg
) == COMPONENT_REF
)
7968 /* Handle `&x' where `x' is some static or non-static member
7970 arg
= TREE_OPERAND (arg
, 1);
7972 if (TREE_CODE (arg
) == OFFSET_REF
)
7973 arg
= TREE_OPERAND (arg
, 1);
7975 /* Strip baselink information. */
7976 while (TREE_CODE (arg
) == TREE_LIST
)
7977 arg
= TREE_VALUE (arg
);
7979 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
7981 /* If we got some explicit template args, we need to plug them into
7982 the affected templates before we try to unify, in case the
7983 explicit args will completely resolve the templates in question. */
7985 tree expl_subargs
= TREE_OPERAND (arg
, 1);
7986 arg
= TREE_OPERAND (arg
, 0);
7988 for (; arg
; arg
= OVL_NEXT (arg
))
7990 tree fn
= OVL_CURRENT (arg
);
7993 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7996 subargs
= get_bindings_overload (fn
, DECL_RESULT (fn
), expl_subargs
);
7999 elem
= tsubst (TREE_TYPE (fn
), subargs
, /*complain=*/0,
8001 if (TREE_CODE (elem
) == METHOD_TYPE
)
8002 elem
= build_ptrmemfunc_type (build_pointer_type (elem
));
8003 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
, elem
,
8004 strict
, sub_strict
);
8008 else if (TREE_CODE (arg
) == OVERLOAD
)
8010 for (; arg
; arg
= OVL_NEXT (arg
))
8012 tree type
= TREE_TYPE (OVL_CURRENT (arg
));
8013 if (TREE_CODE (type
) == METHOD_TYPE
)
8014 type
= build_ptrmemfunc_type (build_pointer_type (type
));
8015 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
8017 strict
, sub_strict
);
8021 my_friendly_abort (981006);
8023 /* [temp.deduct.type] A template-argument can be deduced from a pointer
8024 to function or pointer to member function argument if the set of
8025 overloaded functions does not contain function templates and at most
8026 one of a set of overloaded functions provides a unique match.
8028 So if we found multiple possibilities, we return success but don't
8033 int i
= TREE_VEC_LENGTH (targs
);
8035 if (TREE_VEC_ELT (tempargs
, i
))
8036 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
8044 /* Subroutine of resolve_overloaded_unification; does deduction for a single
8045 overload. Fills TARGS with any deduced arguments, or error_mark_node if
8046 different overloads deduce different arguments for a given parm.
8047 Returns 1 on success. */
8050 try_one_overload (tparms
, orig_targs
, targs
, parm
, arg
, strict
,
8052 tree tparms
, orig_targs
, targs
, parm
, arg
;
8053 unification_kind_t strict
;
8060 /* [temp.deduct.type] A template-argument can be deduced from a pointer
8061 to function or pointer to member function argument if the set of
8062 overloaded functions does not contain function templates and at most
8063 one of a set of overloaded functions provides a unique match.
8065 So if this is a template, just return success. */
8067 if (uses_template_parms (arg
))
8070 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
8072 /* We don't copy orig_targs for this because if we have already deduced
8073 some template args from previous args, unify would complain when we
8074 try to deduce a template parameter for the same argument, even though
8075 there isn't really a conflict. */
8076 nargs
= TREE_VEC_LENGTH (targs
);
8077 tempargs
= make_scratch_vec (nargs
);
8079 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
) != 0)
8082 /* First make sure we didn't deduce anything that conflicts with
8083 explicitly specified args. */
8084 for (i
= nargs
; i
--; )
8086 tree elt
= TREE_VEC_ELT (tempargs
, i
);
8087 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
8089 if (elt
== NULL_TREE
)
8091 else if (uses_template_parms (elt
))
8093 /* Since we're unifying against ourselves, we will fill in template
8094 args used in the function parm list with our own template parms.
8096 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
8099 else if (oldelt
&& ! template_args_equal (oldelt
, elt
))
8103 for (i
= nargs
; i
--; )
8105 tree elt
= TREE_VEC_ELT (tempargs
, i
);
8108 TREE_VEC_ELT (targs
, i
) = elt
;
8114 /* PARM is a template class (perhaps with unbound template
8115 parameters). ARG is a fully instantiated type. If ARG can be
8116 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
8117 TARGS are as for unify. */
8120 try_class_unification (tparms
, targs
, parm
, arg
)
8129 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
8130 || CLASSTYPE_TI_TEMPLATE (arg
) != CLASSTYPE_TI_TEMPLATE (parm
))
8133 /* We need to make a new template argument vector for the call to
8134 unify. If we used TARGS, we'd clutter it up with the result of
8135 the attempted unification, even if this class didn't work out.
8136 We also don't want to commit ourselves to all the unifications
8137 we've already done, since unification is supposed to be done on
8138 an argument-by-argument basis. In other words, consider the
8139 following pathological case:
8141 template <int I, int J, int K>
8144 template <int I, int J>
8145 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
8147 template <int I, int J, int K>
8148 void f(S<I, J, K>, S<I, I, I>);
8157 Now, by the time we consider the unification involving `s2', we
8158 already know that we must have `f<0, 0, 0>'. But, even though
8159 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal
8160 because there are two ways to unify base classes of S<0, 1, 2>
8161 with S<I, I, I>. If we kept the already deduced knowledge, we
8162 would reject the possibility I=1. */
8164 copy_of_targs
= make_temp_vec (TREE_VEC_LENGTH (targs
));
8165 i
= unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
8166 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
);
8169 /* If unification failed, we're done. */
8176 /* Subroutine of get_template_base. RVAL, if non-NULL, is a base we
8177 have alreay discovered to be satisfactory. ARG_BINFO is the binfo
8178 for the base class of ARG that we are currently examining. */
8181 get_template_base_recursive (tparms
, targs
, parm
,
8182 arg_binfo
, rval
, flags
)
8192 tree arg
= BINFO_TYPE (arg_binfo
);
8194 if (!(flags
& GTB_IGNORE_TYPE
))
8196 tree r
= try_class_unification (tparms
, targs
,
8199 /* If there is more than one satisfactory baseclass, then:
8203 If they yield more than one possible deduced A, the type
8207 if (r
&& rval
&& !same_type_p (r
, rval
))
8208 return error_mark_node
;
8213 binfos
= BINFO_BASETYPES (arg_binfo
);
8214 n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
8216 /* Process base types. */
8217 for (i
= 0; i
< n_baselinks
; i
++)
8219 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
8222 /* Skip this base, if we've already seen it. */
8223 if (BINFO_MARKED (base_binfo
))
8227 (flags
& GTB_VIA_VIRTUAL
) || TREE_VIA_VIRTUAL (base_binfo
);
8229 /* When searching for a non-virtual, we cannot mark virtually
8232 SET_BINFO_MARKED (base_binfo
);
8234 rval
= get_template_base_recursive (tparms
, targs
,
8238 GTB_VIA_VIRTUAL
* this_virtual
);
8240 /* If we discovered more than one matching base class, we can
8242 if (rval
== error_mark_node
)
8243 return error_mark_node
;
8249 /* Given a template type PARM and a class type ARG, find the unique
8250 base type in ARG that is an instance of PARM. We do not examine
8251 ARG itself; only its base-classes. If there is no appropriate base
8252 class, return NULL_TREE. If there is more than one, return
8253 error_mark_node. PARM may be the type of a partial specialization,
8254 as well as a plain template type. Used by unify. */
8257 get_template_base (tparms
, targs
, parm
, arg
)
8266 my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg
)), 92);
8268 arg_binfo
= TYPE_BINFO (complete_type (arg
));
8269 rval
= get_template_base_recursive (tparms
, targs
,
8274 /* Since get_template_base_recursive marks the bases classes, we
8275 must unmark them here. */
8276 dfs_walk (arg_binfo
, dfs_unmark
, markedp
, 0);
8281 /* Returns the level of DECL, which declares a template parameter. */
8284 template_decl_level (decl
)
8287 switch (TREE_CODE (decl
))
8291 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
8294 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
8297 my_friendly_abort (0);
8302 /* Decide whether ARG can be unified with PARM, considering only the
8303 cv-qualifiers of each type, given STRICT as documented for unify.
8304 Returns non-zero iff the unification is OK on that basis.*/
8307 check_cv_quals_for_unify (strict
, arg
, parm
)
8312 if (!(strict
& UNIFY_ALLOW_MORE_CV_QUAL
)
8313 && !at_least_as_qualified_p (arg
, parm
))
8316 if (!(strict
& UNIFY_ALLOW_LESS_CV_QUAL
)
8317 && !at_least_as_qualified_p (parm
, arg
))
8323 /* Takes parameters as for type_unification. Returns 0 if the
8324 type deduction suceeds, 1 otherwise. The parameter STRICT is a
8325 bitwise or of the following flags:
8328 Require an exact match between PARM and ARG.
8329 UNIFY_ALLOW_MORE_CV_QUAL:
8330 Allow the deduced ARG to be more cv-qualified than ARG.
8331 UNIFY_ALLOW_LESS_CV_QUAL:
8332 Allow the deduced ARG to be less cv-qualified than ARG.
8333 UNIFY_ALLOW_DERIVED:
8334 Allow the deduced ARG to be a template base class of ARG,
8335 or a pointer to a template base class of the type pointed to by
8337 UNIFY_ALLOW_INTEGER:
8338 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
8339 case for more information. */
8342 unify (tparms
, targs
, parm
, arg
, strict
)
8343 tree tparms
, targs
, parm
, arg
;
8350 /* I don't think this will do the right thing with respect to types.
8351 But the only case I've seen it in so far has been array bounds, where
8352 signedness is the only information lost, and I think that will be
8354 while (TREE_CODE (parm
) == NOP_EXPR
)
8355 parm
= TREE_OPERAND (parm
, 0);
8357 if (arg
== error_mark_node
)
8359 if (arg
== unknown_type_node
)
8360 /* We can't deduce anything from this, but we might get all the
8361 template args from other function args. */
8364 /* If PARM uses template parameters, then we can't bail out here,
8365 even if ARG == PARM, since we won't record unifications for the
8366 template parameters. We might need them if we're trying to
8367 figure out which of two things is more specialized. */
8368 if (arg
== parm
&& !uses_template_parms (parm
))
8371 /* Immediately reject some pairs that won't unify because of
8372 cv-qualification mismatches. */
8373 if (TREE_CODE (arg
) == TREE_CODE (parm
)
8374 && TREE_CODE_CLASS (TREE_CODE (arg
)) == 't'
8375 /* We check the cv-qualifiers when unifying with template type
8376 parameters below. We want to allow ARG `const T' to unify with
8377 PARM `T' for example, when computing which of two templates
8378 is more specialized, for example. */
8379 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
8380 && !check_cv_quals_for_unify (strict
, arg
, parm
))
8383 switch (TREE_CODE (parm
))
8386 /* In a type which contains a nested-name-specifier, template
8387 argument values cannot be deduced for template parameters used
8388 within the nested-name-specifier. */
8391 case TEMPLATE_TYPE_PARM
:
8392 case TEMPLATE_TEMPLATE_PARM
:
8393 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
8395 if (TEMPLATE_TYPE_LEVEL (parm
)
8396 != template_decl_level (tparm
))
8397 /* The PARM is not one we're trying to unify. Just check
8398 to see if it matches ARG. */
8399 return (TREE_CODE (arg
) == TREE_CODE (parm
)
8400 && same_type_p (parm
, arg
)) ? 0 : 1;
8401 idx
= TEMPLATE_TYPE_IDX (parm
);
8402 targ
= TREE_VEC_ELT (targs
, idx
);
8403 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
8405 /* Check for mixed types and values. */
8406 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
8407 && TREE_CODE (tparm
) != TYPE_DECL
)
8408 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
8409 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
8412 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
8414 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
))
8416 /* We arrive here when PARM does not involve template
8419 /* ARG must be constructed from a template class. */
8420 if (TREE_CODE (arg
) != RECORD_TYPE
|| !CLASSTYPE_TEMPLATE_INFO (arg
))
8424 tree parmtmpl
= TYPE_TI_TEMPLATE (parm
);
8425 tree parmvec
= TYPE_TI_ARGS (parm
);
8426 tree argvec
= CLASSTYPE_TI_ARGS (arg
);
8428 = DECL_INNERMOST_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (arg
));
8431 /* The parameter and argument roles have to be switched here
8432 in order to handle default arguments properly. For example,
8433 template<template <class> class TT> void f(TT<int>)
8434 should be able to accept vector<int> which comes from
8435 template <class T, class Allocator = allocator>
8438 if (coerce_template_parms (argtmplvec
, parmvec
, parmtmpl
, 0, 1)
8442 /* Deduce arguments T, i from TT<T> or TT<i>.
8443 We check each element of PARMVEC and ARGVEC individually
8444 rather than the whole TREE_VEC since they can have
8445 different number of elements. */
8447 for (i
= 0; i
< TREE_VEC_LENGTH (parmvec
); ++i
)
8449 tree t
= TREE_VEC_ELT (parmvec
, i
);
8451 if (unify (tparms
, targs
, t
,
8452 TREE_VEC_ELT (argvec
, i
),
8457 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
8462 /* If PARM is `const T' and ARG is only `int', we don't have
8463 a match unless we are allowing additional qualification.
8464 If ARG is `const int' and PARM is just `T' that's OK;
8465 that binds `const int' to `T'. */
8466 if (!check_cv_quals_for_unify (strict
| UNIFY_ALLOW_LESS_CV_QUAL
,
8470 /* Consider the case where ARG is `const volatile int' and
8471 PARM is `const T'. Then, T should be `volatile int'. */
8473 cp_build_qualified_type_real (arg
,
8475 & ~CP_TYPE_QUALS (parm
),
8477 if (arg
== error_mark_node
)
8481 /* Simple cases: Value already set, does match or doesn't. */
8482 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
8487 /* Make sure that ARG is not a variable-sized array. (Note that
8488 were talking about variable-sized arrays (like `int[n]'),
8489 rather than arrays of unknown size (like `int[]').) We'll
8490 get very confused by such a type since the bound of the array
8491 will not be computable in an instantiation. Besides, such
8492 types are not allowed in ISO C++, so we can do as we please
8494 if (TREE_CODE (arg
) == ARRAY_TYPE
8495 && !uses_template_parms (arg
)
8496 && (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (arg
)))
8500 TREE_VEC_ELT (targs
, idx
) = arg
;
8503 case TEMPLATE_PARM_INDEX
:
8504 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
8506 if (TEMPLATE_PARM_LEVEL (parm
)
8507 != template_decl_level (tparm
))
8508 /* The PARM is not one we're trying to unify. Just check
8509 to see if it matches ARG. */
8510 return (TREE_CODE (arg
) == TREE_CODE (parm
)
8511 && cp_tree_equal (parm
, arg
) > 0) ? 0 : 1;
8513 idx
= TEMPLATE_PARM_IDX (parm
);
8514 targ
= TREE_VEC_ELT (targs
, idx
);
8518 int i
= (cp_tree_equal (targ
, arg
) > 0);
8524 my_friendly_abort (42);
8527 /* [temp.deduct.type] If, in the declaration of a function template
8528 with a non-type template-parameter, the non-type
8529 template-parameter is used in an expression in the function
8530 parameter-list and, if the corresponding template-argument is
8531 deduced, the template-argument type shall match the type of the
8532 template-parameter exactly, except that a template-argument
8533 deduced from an array bound may be of any integral type. */
8534 if (same_type_p (TREE_TYPE (arg
), TREE_TYPE (parm
)))
8536 else if ((strict
& UNIFY_ALLOW_INTEGER
)
8537 && (TREE_CODE (TREE_TYPE (parm
)) == INTEGER_TYPE
8538 || TREE_CODE (TREE_TYPE (parm
)) == BOOLEAN_TYPE
))
8543 TREE_VEC_ELT (targs
, idx
) = arg
;
8550 if (TREE_CODE (arg
) != POINTER_TYPE
)
8553 /* [temp.deduct.call]
8555 A can be another pointer or pointer to member type that can
8556 be converted to the deduced A via a qualification
8557 conversion (_conv.qual_).
8559 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
8560 This will allow for additional cv-qualification of the
8561 pointed-to types if appropriate. In general, this is a bit
8562 too generous; we are only supposed to allow qualification
8563 conversions and this method will allow an ARG of char** and
8564 a deduced ARG of const char**. However, overload
8565 resolution will subsequently invalidate the candidate, so
8566 this is probably OK. */
8567 sub_strict
= strict
;
8569 if (TREE_CODE (TREE_TYPE (arg
)) != RECORD_TYPE
)
8570 /* The derived-to-base conversion only persists through one
8571 level of pointers. */
8572 sub_strict
&= ~UNIFY_ALLOW_DERIVED
;
8574 return unify (tparms
, targs
, TREE_TYPE (parm
),
8575 TREE_TYPE (arg
), sub_strict
);
8578 case REFERENCE_TYPE
:
8579 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
8581 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8585 if (TREE_CODE (arg
) != ARRAY_TYPE
)
8587 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
8588 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
8590 if (TYPE_DOMAIN (parm
) != NULL_TREE
8591 && unify (tparms
, targs
, TYPE_DOMAIN (parm
),
8592 TYPE_DOMAIN (arg
), UNIFY_ALLOW_NONE
) != 0)
8594 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8602 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8605 if (TREE_CODE (parm
) == INTEGER_TYPE
8606 && TREE_CODE (TYPE_MAX_VALUE (parm
)) != INTEGER_CST
)
8608 if (TYPE_MIN_VALUE (parm
) && TYPE_MIN_VALUE (arg
)
8609 && unify (tparms
, targs
, TYPE_MIN_VALUE (parm
),
8610 TYPE_MIN_VALUE (arg
), UNIFY_ALLOW_INTEGER
))
8612 if (TYPE_MAX_VALUE (parm
) && TYPE_MAX_VALUE (arg
)
8613 && unify (tparms
, targs
, TYPE_MAX_VALUE (parm
),
8614 TYPE_MAX_VALUE (arg
), UNIFY_ALLOW_INTEGER
))
8617 /* We use the TYPE_MAIN_VARIANT since we have already
8618 checked cv-qualification at the top of the
8620 else if (!same_type_p (TYPE_MAIN_VARIANT (arg
),
8621 TYPE_MAIN_VARIANT (parm
)))
8624 /* As far as unification is concerned, this wins. Later checks
8625 will invalidate it if necessary. */
8628 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
8629 /* Type INTEGER_CST can come from ordinary constant template args. */
8631 while (TREE_CODE (arg
) == NOP_EXPR
)
8632 arg
= TREE_OPERAND (arg
, 0);
8634 if (TREE_CODE (arg
) != INTEGER_CST
)
8636 return !tree_int_cst_equal (parm
, arg
);
8641 if (TREE_CODE (arg
) != TREE_VEC
)
8643 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
8645 for (i
= TREE_VEC_LENGTH (parm
) - 1; i
>= 0; i
--)
8646 if (unify (tparms
, targs
,
8647 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
8655 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8658 if (TYPE_PTRMEMFUNC_P (parm
))
8660 if (!TYPE_PTRMEMFUNC_P (arg
))
8663 return unify (tparms
, targs
,
8664 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
8665 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
8669 if (CLASSTYPE_TEMPLATE_INFO (parm
))
8673 if (strict
& UNIFY_ALLOW_DERIVED
)
8675 /* First, we try to unify the PARM and ARG directly. */
8676 t
= try_class_unification (tparms
, targs
,
8681 /* Fallback to the special case allowed in
8684 If P is a class, and P has the form
8685 template-id, then A can be a derived class of
8686 the deduced A. Likewise, if P is a pointer to
8687 a class of the form template-id, A can be a
8688 pointer to a derived class pointed to by the
8690 t
= get_template_base (tparms
, targs
,
8693 if (! t
|| t
== error_mark_node
)
8697 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
8698 && (CLASSTYPE_TI_TEMPLATE (parm
)
8699 == CLASSTYPE_TI_TEMPLATE (arg
)))
8700 /* Perhaps PARM is something like S<U> and ARG is S<int>.
8701 Then, we should unify `int' and `U'. */
8704 /* There's no chance of unication succeeding. */
8707 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
8708 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
);
8710 else if (!same_type_p (TYPE_MAIN_VARIANT (parm
),
8711 TYPE_MAIN_VARIANT (arg
)))
8717 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8720 if (unify (tparms
, targs
, TREE_TYPE (parm
),
8721 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
))
8723 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
8724 TYPE_ARG_TYPES (arg
), 1,
8728 if (TREE_CODE (arg
) != OFFSET_TYPE
)
8730 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
8731 TYPE_OFFSET_BASETYPE (arg
), UNIFY_ALLOW_NONE
))
8733 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8737 if (arg
!= decl_constant_value (parm
))
8742 /* Matched cases are handled by the ARG == PARM test above. */
8746 if (TREE_CODE (TREE_OPERAND (parm
, 1)) == INTEGER_CST
)
8748 /* We handle this case specially, since it comes up with
8749 arrays. In particular, something like:
8751 template <int N> void f(int (&x)[N]);
8753 Here, we are trying to unify the range type, which
8754 looks like [0 ... (N - 1)]. */
8756 t1
= TREE_OPERAND (parm
, 0);
8757 t2
= TREE_OPERAND (parm
, 1);
8759 /* Should this be a regular fold? */
8760 t
= maybe_fold_nontype_arg (build (PLUS_EXPR
,
8764 return unify (tparms
, targs
, t1
, t
, strict
);
8766 /* else fall through */
8769 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm
))))
8770 /* We're looking at an expression. This can happen with
8774 void foo(S<I>, S<I + 2>);
8776 This is a "nondeduced context":
8780 The nondeduced contexts are:
8782 --A type that is a template-id in which one or more of
8783 the template-arguments is an expression that references
8784 a template-parameter.
8786 In these cases, we assume deduction succeeded, but don't
8787 actually infer any unifications. */
8790 sorry ("use of `%s' in template type unification",
8791 tree_code_name
[(int) TREE_CODE (parm
)]);
8797 /* Called if RESULT is explicitly instantiated, or is a member of an
8798 explicitly instantiated class, or if using -frepo and the
8799 instantiation of RESULT has been assigned to this file. */
8802 mark_decl_instantiated (result
, extern_p
)
8806 if (TREE_CODE (result
) != FUNCTION_DECL
)
8807 /* The TREE_PUBLIC flag for function declarations will have been
8808 set correctly by tsubst. */
8809 TREE_PUBLIC (result
) = 1;
8813 DECL_INTERFACE_KNOWN (result
) = 1;
8814 DECL_NOT_REALLY_EXTERN (result
) = 1;
8816 /* Always make artificials weak. */
8817 if (DECL_ARTIFICIAL (result
) && flag_weak
)
8818 comdat_linkage (result
);
8819 /* For WIN32 we also want to put explicit instantiations in
8820 linkonce sections. */
8821 else if (TREE_PUBLIC (result
))
8822 maybe_make_one_only (result
);
8824 else if (TREE_CODE (result
) == FUNCTION_DECL
)
8825 mark_inline_for_output (result
);
8828 /* Given two function templates PAT1 and PAT2, and explicit template
8829 arguments EXPLICIT_ARGS return:
8831 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
8832 -1 if PAT2 is more specialized than PAT1.
8833 0 if neither is more specialized. */
8836 more_specialized (pat1
, pat2
, explicit_args
)
8837 tree pat1
, pat2
, explicit_args
;
8842 targs
= get_bindings_overload (pat1
, DECL_RESULT (pat2
), explicit_args
);
8846 targs
= get_bindings_overload (pat2
, DECL_RESULT (pat1
), explicit_args
);
8853 /* Given two class template specialization list nodes PAT1 and PAT2, return:
8855 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
8856 -1 if PAT2 is more specialized than PAT1.
8857 0 if neither is more specialized. */
8860 more_specialized_class (pat1
, pat2
)
8866 targs
= get_class_bindings (TREE_VALUE (pat1
), TREE_PURPOSE (pat1
),
8867 TREE_PURPOSE (pat2
));
8871 targs
= get_class_bindings (TREE_VALUE (pat2
), TREE_PURPOSE (pat2
),
8872 TREE_PURPOSE (pat1
));
8879 /* Return the template arguments that will produce the function signature
8880 DECL from the function template FN, with the explicit template
8881 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
8882 also match. Return NULL_TREE if no satisfactory arguments could be
8886 get_bindings_real (fn
, decl
, explicit_args
, check_rettype
)
8887 tree fn
, decl
, explicit_args
;
8890 int ntparms
= DECL_NTPARMS (fn
);
8891 tree targs
= make_scratch_vec (ntparms
);
8893 tree decl_arg_types
;
8896 /* Substitute the explicit template arguments into the type of DECL.
8897 The call to fn_type_unification will handle substitution into the
8899 decl_type
= TREE_TYPE (decl
);
8900 if (explicit_args
&& uses_template_parms (decl_type
))
8903 tree converted_args
;
8905 if (DECL_TEMPLATE_INFO (decl
))
8906 tmpl
= DECL_TI_TEMPLATE (decl
);
8908 /* We can get here for some illegal specializations. */
8912 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
8913 explicit_args
, NULL_TREE
,
8915 /*require_all_arguments=*/0));
8916 if (converted_args
== error_mark_node
)
8919 decl_type
= tsubst (decl_type
, converted_args
, /*complain=*/0,
8921 if (decl_type
== error_mark_node
)
8925 /* If FN is a static member function, adjust the type of DECL
8927 decl_arg_types
= TYPE_ARG_TYPES (decl_type
);
8928 if (DECL_STATIC_FUNCTION_P (fn
)
8929 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
8930 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
8932 i
= fn_type_unification (fn
, explicit_args
, targs
,
8934 TREE_TYPE (decl_type
),
8942 /* Check to see that the resulting return type is also OK. */
8943 tree t
= tsubst (TREE_TYPE (TREE_TYPE (fn
)), targs
,
8944 /*complain=*/0, NULL_TREE
);
8946 if (!same_type_p (t
, TREE_TYPE (TREE_TYPE (decl
))))
8953 /* For most uses, we want to check the return type. */
8956 get_bindings (fn
, decl
, explicit_args
)
8957 tree fn
, decl
, explicit_args
;
8959 return get_bindings_real (fn
, decl
, explicit_args
, 1);
8962 /* But for more_specialized, we only care about the parameter types. */
8965 get_bindings_overload (fn
, decl
, explicit_args
)
8966 tree fn
, decl
, explicit_args
;
8968 return get_bindings_real (fn
, decl
, explicit_args
, 0);
8971 /* Return the innermost template arguments that, when applied to a
8972 template specialization whose innermost template parameters are
8973 TPARMS, and whose specialization arguments are ARGS, yield the
8976 For example, suppose we have:
8978 template <class T, class U> struct S {};
8979 template <class T> struct S<T*, int> {};
8981 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
8982 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
8983 int}. The resulting vector will be {double}, indicating that `T'
8984 is bound to `double'. */
8987 get_class_bindings (tparms
, parms
, args
)
8988 tree tparms
, parms
, args
;
8990 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
8991 tree vec
= make_temp_vec (ntparms
);
8993 args
= innermost_args (args
);
8995 if (unify (tparms
, vec
, parms
, args
, UNIFY_ALLOW_NONE
))
8998 for (i
= 0; i
< ntparms
; ++i
)
8999 if (! TREE_VEC_ELT (vec
, i
))
9005 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
9006 Pick the most specialized template, and return the corresponding
9007 instantiation, or if there is no corresponding instantiation, the
9008 template itself. EXPLICIT_ARGS is any template arguments explicity
9009 mentioned in a template-id. If there is no most specialized
9010 tempalte, error_mark_node is returned. If there are no templates
9011 at all, NULL_TREE is returned. */
9014 most_specialized_instantiation (instantiations
, explicit_args
)
9015 tree instantiations
;
9021 if (!instantiations
)
9024 champ
= instantiations
;
9025 for (fn
= TREE_CHAIN (instantiations
); fn
; fn
= TREE_CHAIN (fn
))
9027 fate
= more_specialized (TREE_VALUE (champ
),
9028 TREE_VALUE (fn
), explicit_args
);
9035 fn
= TREE_CHAIN (fn
);
9037 return error_mark_node
;
9043 for (fn
= instantiations
; fn
&& fn
!= champ
; fn
= TREE_CHAIN (fn
))
9045 fate
= more_specialized (TREE_VALUE (champ
),
9046 TREE_VALUE (fn
), explicit_args
);
9048 return error_mark_node
;
9051 return TREE_PURPOSE (champ
) ? TREE_PURPOSE (champ
) : TREE_VALUE (champ
);
9054 /* Return the most specialized of the list of templates in FNS that can
9055 produce an instantiation matching DECL, given the explicit template
9056 arguments EXPLICIT_ARGS. */
9059 most_specialized (fns
, decl
, explicit_args
)
9060 tree fns
, decl
, explicit_args
;
9062 tree candidates
= NULL_TREE
;
9065 for (fn
= fns
; fn
; fn
= TREE_CHAIN (fn
))
9067 tree candidate
= TREE_VALUE (fn
);
9069 args
= get_bindings (candidate
, decl
, explicit_args
);
9071 candidates
= tree_cons (NULL_TREE
, candidate
, candidates
);
9074 return most_specialized_instantiation (candidates
, explicit_args
);
9077 /* If DECL is a specialization of some template, return the most
9078 general such template. For example, given:
9080 template <class T> struct S { template <class U> void f(U); };
9082 if TMPL is `template <class U> void S<int>::f(U)' this will return
9083 the full template. This function will not trace past partial
9084 specializations, however. For example, given in addition:
9086 template <class T> struct S<T*> { template <class U> void f(U); };
9088 if TMPL is `template <class U> void S<int*>::f(U)' this will return
9089 `template <class T> template <class U> S<T*>::f(U)'. */
9092 most_general_template (decl
)
9095 while (DECL_TEMPLATE_INFO (decl
))
9096 decl
= DECL_TI_TEMPLATE (decl
);
9101 /* Return the most specialized of the class template specializations
9102 of TMPL which can produce an instantiation matching ARGS, or
9103 error_mark_node if the choice is ambiguous. */
9106 most_specialized_class (tmpl
, args
)
9110 tree list
= NULL_TREE
;
9115 tmpl
= most_general_template (tmpl
);
9116 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
9119 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
), args
);
9122 list
= decl_tree_cons (TREE_PURPOSE (t
), TREE_VALUE (t
), list
);
9123 TREE_TYPE (list
) = TREE_TYPE (t
);
9133 for (; t
; t
= TREE_CHAIN (t
))
9135 fate
= more_specialized_class (champ
, t
);
9144 return error_mark_node
;
9150 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
9152 fate
= more_specialized_class (champ
, t
);
9154 return error_mark_node
;
9160 /* called from the parser. */
9163 do_decl_instantiation (declspecs
, declarator
, storage
)
9164 tree declspecs
, declarator
, storage
;
9166 tree decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, 0, NULL_TREE
);
9167 tree result
= NULL_TREE
;
9171 /* An error ocurred, for which grokdeclarator has already issued
9172 an appropriate message. */
9174 else if (! DECL_LANG_SPECIFIC (decl
))
9176 cp_error ("explicit instantiation of non-template `%#D'", decl
);
9179 else if (TREE_CODE (decl
) == VAR_DECL
)
9181 /* There is an asymmetry here in the way VAR_DECLs and
9182 FUNCTION_DECLs are handled by grokdeclarator. In the case of
9183 the latter, the DECL we get back will be marked as a
9184 template instantiation, and the appropriate
9185 DECL_TEMPLATE_INFO will be set up. This does not happen for
9186 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
9187 should handle VAR_DECLs as it currently handles
9189 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, 0);
9190 if (result
&& TREE_CODE (result
) != VAR_DECL
)
9192 cp_error ("no matching template for `%D' found", result
);
9196 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
9198 cp_error ("explicit instantiation of `%#D'", decl
);
9204 /* Check for various error cases. Note that if the explicit
9205 instantiation is legal the RESULT will currently be marked as an
9206 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
9207 until we get here. */
9209 if (DECL_TEMPLATE_SPECIALIZATION (result
))
9213 No program shall both explicitly instantiate and explicitly
9214 specialize a template. */
9215 cp_pedwarn ("explicit instantiation of `%#D' after", result
);
9216 cp_pedwarn_at ("explicit specialization here", result
);
9219 else if (DECL_EXPLICIT_INSTANTIATION (result
))
9223 No program shall explicitly instantiate any template more
9226 We check DECL_INTERFACE_KNOWN so as not to complain when the first
9227 instantiation was `extern' and the second is not, and EXTERN_P for
9228 the opposite case. If -frepo, chances are we already got marked
9229 as an explicit instantion because of the repo file. */
9230 if (DECL_INTERFACE_KNOWN (result
) && !extern_p
&& !flag_use_repository
)
9231 cp_pedwarn ("duplicate explicit instantiation of `%#D'", result
);
9233 /* If we've already instantiated the template, just return now. */
9234 if (DECL_INTERFACE_KNOWN (result
))
9237 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
9239 cp_error ("no matching template for `%D' found", result
);
9242 else if (!DECL_TEMPLATE_INFO (result
))
9244 cp_pedwarn ("explicit instantiation of non-template `%#D'", result
);
9248 if (flag_external_templates
)
9251 if (storage
== NULL_TREE
)
9253 else if (storage
== ridpointers
[(int) RID_EXTERN
])
9256 cp_pedwarn ("ANSI C++ forbids the use of `extern' on explicit instantiations");
9260 cp_error ("storage class `%D' applied to template instantiation",
9263 SET_DECL_EXPLICIT_INSTANTIATION (result
);
9264 mark_decl_instantiated (result
, extern_p
);
9265 repo_template_instantiated (result
, extern_p
);
9267 instantiate_decl (result
);
9271 mark_class_instantiated (t
, extern_p
)
9275 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
9276 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
9277 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
9278 CLASSTYPE_VTABLE_NEEDS_WRITING (t
) = ! extern_p
;
9279 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
9282 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
9283 rest_of_type_compilation (t
, 1);
9288 do_type_instantiation (t
, storage
)
9295 if (TREE_CODE (t
) == TYPE_DECL
)
9298 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
9300 cp_error ("explicit instantiation of non-template type `%T'", t
);
9306 /* With -fexternal-templates, explicit instantiations are treated the same
9307 as implicit ones. */
9308 if (flag_external_templates
)
9311 if (TYPE_SIZE (t
) == NULL_TREE
)
9313 cp_error ("explicit instantiation of `%#T' before definition of template",
9318 if (storage
!= NULL_TREE
)
9321 cp_pedwarn("ANSI C++ forbids the use of `%s' on explicit instantiations",
9322 IDENTIFIER_POINTER (storage
));
9324 if (storage
== ridpointers
[(int) RID_INLINE
])
9326 else if (storage
== ridpointers
[(int) RID_EXTERN
])
9328 else if (storage
== ridpointers
[(int) RID_STATIC
])
9332 cp_error ("storage class `%D' applied to template instantiation",
9338 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
9342 No program shall both explicitly instantiate and explicitly
9343 specialize a template. */
9344 cp_error ("explicit instantiation of `%#T' after", t
);
9345 cp_error_at ("explicit specialization here", t
);
9348 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
9352 No program shall explicitly instantiate any template more
9355 If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation
9356 was `extern'. If EXTERN_P then the second is. If -frepo, chances
9357 are we already got marked as an explicit instantion because of the
9358 repo file. All these cases are OK. */
9359 if (!CLASSTYPE_INTERFACE_ONLY (t
) && !extern_p
&& !flag_use_repository
)
9360 cp_pedwarn ("duplicate explicit instantiation of `%#T'", t
);
9362 /* If we've already instantiated the template, just return now. */
9363 if (!CLASSTYPE_INTERFACE_ONLY (t
))
9367 mark_class_instantiated (t
, extern_p
);
9368 repo_template_instantiated (t
, extern_p
);
9376 /* In contrast to implicit instantiation, where only the
9377 declarations, and not the definitions, of members are
9378 instantiated, we have here:
9382 The explicit instantiation of a class template specialization
9383 implies the instantiation of all of its members not
9384 previously explicitly specialized in the translation unit
9385 containing the explicit instantiation.
9387 Of course, we can't instantiate member template classes, since
9388 we don't have any arguments for them. Note that the standard
9389 is unclear on whether the instatiation of the members are
9390 *explicit* instantiations or not. We choose to be generous,
9391 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
9392 the explicit instantiation of a class where some of the members
9393 have no definition in the current translation unit. */
9396 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
9397 if (TREE_CODE (tmp
) == FUNCTION_DECL
9398 && DECL_TEMPLATE_INSTANTIATION (tmp
))
9400 mark_decl_instantiated (tmp
, extern_p
);
9401 repo_template_instantiated (tmp
, extern_p
);
9403 instantiate_decl (tmp
);
9406 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
9407 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
9409 mark_decl_instantiated (tmp
, extern_p
);
9410 repo_template_instantiated (tmp
, extern_p
);
9412 instantiate_decl (tmp
);
9415 for (tmp
= CLASSTYPE_TAGS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
9416 if (IS_AGGR_TYPE (TREE_VALUE (tmp
))
9417 && !uses_template_parms (CLASSTYPE_TI_ARGS (TREE_VALUE (tmp
))))
9418 do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp
)), storage
);
9422 /* Given a function DECL, which is a specialization of TMPL, modify
9423 DECL to be a re-instantiation of TMPL with the same template
9424 arguments. TMPL should be the template into which tsubst'ing
9425 should occur for DECL, not the most general template.
9427 One reason for doing this is a scenario like this:
9430 void f(const T&, int i);
9432 void g() { f(3, 7); }
9435 void f(const T& t, const int i) { }
9437 Note that when the template is first instantiated, with
9438 instantiate_template, the resulting DECL will have no name for the
9439 first parameter, and the wrong type for the second. So, when we go
9440 to instantiate the DECL, we regenerate it. */
9443 regenerate_decl_from_template (decl
, tmpl
)
9453 args
= DECL_TI_ARGS (decl
);
9454 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9456 /* Unregister the specialization so that when we tsubst we will not
9457 just return DECL. We don't have to unregister DECL from TMPL
9458 because if would only be registered there if it were a partial
9459 instantiation of a specialization, which it isn't: it's a full
9461 gen_tmpl
= most_general_template (tmpl
);
9462 unregistered
= unregister_specialization (decl
, gen_tmpl
);
9464 /* If the DECL was not unregistered then something peculiar is
9465 happening: we created a specialization but did not call
9466 register_specialization for it. */
9467 my_friendly_assert (unregistered
, 0);
9469 if (TREE_CODE (decl
) == VAR_DECL
)
9470 /* Make sure that we can see identifiers, and compute access
9471 correctly, for the class members used in the declaration of
9472 this static variable. */
9473 pushclass (DECL_CONTEXT (decl
), 2);
9475 /* Do the substitution to get the new declaration. */
9476 new_decl
= tsubst (code_pattern
, args
, /*complain=*/1, NULL_TREE
);
9478 if (TREE_CODE (decl
) == VAR_DECL
)
9480 /* Set up DECL_INITIAL, since tsubst doesn't. */
9481 DECL_INITIAL (new_decl
) =
9482 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
9483 /*complain=*/1, DECL_TI_TEMPLATE (decl
));
9484 /* Pop the class context we pushed above. */
9487 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
9489 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
9491 DECL_INITIAL (new_decl
) = error_mark_node
;
9492 /* And don't complain about a duplicate definition. */
9493 DECL_INITIAL (decl
) = NULL_TREE
;
9496 /* The immediate parent of the new template is still whatever it was
9497 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
9498 general template. We also reset the DECL_ASSEMBLER_NAME since
9499 tsubst always calculates the name as if the function in question
9500 were really a template instance, and sometimes, with friend
9501 functions, this is not so. See tsubst_friend_function for
9503 DECL_TI_TEMPLATE (new_decl
) = DECL_TI_TEMPLATE (decl
);
9504 DECL_ASSEMBLER_NAME (new_decl
) = DECL_ASSEMBLER_NAME (decl
);
9505 DECL_RTL (new_decl
) = DECL_RTL (decl
);
9507 /* Call duplicate decls to merge the old and new declarations. */
9508 duplicate_decls (new_decl
, decl
);
9510 /* Now, re-register the specialization. */
9511 register_specialization (decl
, gen_tmpl
, args
);
9514 /* Produce the definition of D, a _DECL generated from a template. */
9517 instantiate_decl (d
)
9520 tree tmpl
= DECL_TI_TEMPLATE (d
);
9521 tree args
= DECL_TI_ARGS (d
);
9526 int nested
= in_function_p ();
9527 int pattern_defined
;
9529 char *file
= input_filename
;
9531 /* This function should only be used to instantiate templates for
9532 functions and static member variables. */
9533 my_friendly_assert (TREE_CODE (d
) == FUNCTION_DECL
9534 || TREE_CODE (d
) == VAR_DECL
, 0);
9536 if (DECL_TEMPLATE_INSTANTIATED (d
))
9537 /* D has already been instantiated. It might seem reasonable to
9538 check whether or not D is an explict instantiation, and, if so,
9539 stop here. But when an explicit instantiation is deferred
9540 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
9541 is set, even though we still need to do the instantiation. */
9544 /* If we already have a specialization of this declaration, then
9545 there's no reason to instantiate it. Note that
9546 retrieve_specialization gives us both instantiations and
9547 specializations, so we must explicitly check
9548 DECL_TEMPLATE_SPECIALIZATION. */
9549 gen_tmpl
= most_general_template (tmpl
);
9550 spec
= retrieve_specialization (gen_tmpl
, args
);
9551 if (spec
!= NULL_TREE
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
9554 /* This needs to happen before any tsubsting. */
9555 if (! push_tinst_level (d
))
9558 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
9559 for the instantiation. This is not always the most general
9560 template. Consider, for example:
9563 struct S { template <class U> void f();
9564 template <> void f<int>(); };
9566 and an instantiation of S<double>::f<int>. We want TD to be the
9567 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
9570 /* An instantiation cannot have a definition, so we need a
9571 more general template. */
9572 DECL_TEMPLATE_INSTANTIATION (td
)
9573 /* We must also deal with friend templates. Given:
9575 template <class T> struct S {
9576 template <class U> friend void f() {};
9579 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
9580 so far as the language is concerned, but that's still
9581 where we get the pattern for the instantiation from. On
9582 ther hand, if the definition comes outside the class, say:
9584 template <class T> struct S {
9585 template <class U> friend void f();
9587 template <class U> friend void f() {}
9589 we don't need to look any further. That's what the check for
9590 DECL_INITIAL is for. */
9591 || (TREE_CODE (d
) == FUNCTION_DECL
9592 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (td
)
9593 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (td
)));
9596 /* The present template, TD, should not be a definition. If it
9597 were a definition, we should be using it! Note that we
9598 cannot restructure the loop to just keep going until we find
9599 a template with a definition, since that might go too far if
9600 a specialization was declared, but not defined. */
9601 my_friendly_assert (!(TREE_CODE (d
) == VAR_DECL
9602 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (td
))),
9605 /* Fetch the more general template. */
9606 td
= DECL_TI_TEMPLATE (td
);
9609 code_pattern
= DECL_TEMPLATE_RESULT (td
);
9611 if (TREE_CODE (d
) == FUNCTION_DECL
)
9612 pattern_defined
= (DECL_INITIAL (code_pattern
) != NULL_TREE
);
9614 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
9616 push_to_top_level ();
9617 lineno
= DECL_SOURCE_LINE (d
);
9618 input_filename
= DECL_SOURCE_FILE (d
);
9620 if (pattern_defined
)
9622 repo_template_used (d
);
9624 if (flag_external_templates
&& ! DECL_INTERFACE_KNOWN (d
))
9626 if (flag_alt_external_templates
)
9628 if (interface_unknown
)
9629 warn_if_unknown_interface (d
);
9631 else if (DECL_INTERFACE_KNOWN (code_pattern
))
9633 DECL_INTERFACE_KNOWN (d
) = 1;
9634 DECL_NOT_REALLY_EXTERN (d
) = ! DECL_EXTERNAL (code_pattern
);
9637 warn_if_unknown_interface (code_pattern
);
9641 import_export_decl (d
);
9644 /* Reject all external templates except inline functions. */
9645 if (DECL_INTERFACE_KNOWN (d
)
9646 && ! DECL_NOT_REALLY_EXTERN (d
)
9647 && ! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
)))
9650 if (TREE_CODE (d
) == VAR_DECL
9651 && TREE_READONLY (d
)
9652 && DECL_INITIAL (d
) == NULL_TREE
9653 && DECL_INITIAL (code_pattern
) != NULL_TREE
)
9654 /* We need to set up DECL_INITIAL regardless of pattern_defined if
9655 the variable is a static const initialized in the class body. */;
9656 else if (! pattern_defined
9657 || (! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
) && nested
)
9660 /* Defer all templates except inline functions used in another
9661 function. We restore the source position here because it's used
9662 by add_pending_template. */
9664 input_filename
= file
;
9666 if (at_eof
&& !pattern_defined
9667 && DECL_EXPLICIT_INSTANTIATION (d
))
9670 The definition of a non-exported function template, a
9671 non-exported member function template, or a non-exported
9672 member function or static data member of a class template
9673 shall be present in every translation unit in which it is
9674 explicitly instantiated. */
9675 cp_error ("explicit instantiation of `%D' but no definition available",
9678 add_pending_template (d
);
9682 /* We're now committed to instantiating this template. Mark it as
9683 instantiated so that recursive calls to instantiate_decl do not
9684 try to instantiate it again. */
9685 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
9687 /* Regenerate the declaration in case the template has been modified
9688 by a subsequent redeclaration. */
9689 regenerate_decl_from_template (d
, td
);
9691 /* We already set the file and line above. Reset them now in case
9692 they changed as a result of calling regenerate_decl_from_template. */
9693 lineno
= DECL_SOURCE_LINE (d
);
9694 input_filename
= DECL_SOURCE_FILE (d
);
9696 if (TREE_CODE (d
) == VAR_DECL
)
9698 DECL_IN_AGGR_P (d
) = 0;
9699 if (DECL_INTERFACE_KNOWN (d
))
9700 DECL_EXTERNAL (d
) = ! DECL_NOT_REALLY_EXTERN (d
);
9703 DECL_EXTERNAL (d
) = 1;
9704 DECL_NOT_REALLY_EXTERN (d
) = 1;
9706 cp_finish_decl (d
, DECL_INITIAL (d
), NULL_TREE
, 0, 0);
9708 else if (TREE_CODE (d
) == FUNCTION_DECL
)
9710 /* Set up context. */
9711 start_function (NULL_TREE
, d
, NULL_TREE
, SF_PRE_PARSED
);
9712 store_parm_decls ();
9714 /* Substitute into the body of the function. */
9715 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
9716 /*complain=*/1, tmpl
);
9718 /* Finish the function. */
9719 expand_body (finish_function (lineno
, 0));
9724 input_filename
= file
;
9726 pop_from_top_level ();
9732 /* Run through the list of templates that we wish we could
9733 instantiate, and instantiate any we can. */
9736 instantiate_pending_templates ()
9739 int instantiated_something
= 0;
9746 t
= &pending_templates
;
9749 tree srcloc
= TREE_PURPOSE (*t
);
9750 tree instantiation
= TREE_VALUE (*t
);
9752 input_filename
= SRCLOC_FILE (srcloc
);
9753 lineno
= SRCLOC_LINE (srcloc
);
9755 if (TREE_CODE_CLASS (TREE_CODE (instantiation
)) == 't')
9759 if (!TYPE_SIZE (instantiation
))
9761 instantiate_class_template (instantiation
);
9762 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
9763 for (fn
= TYPE_METHODS (instantiation
);
9765 fn
= TREE_CHAIN (fn
))
9766 if (! DECL_ARTIFICIAL (fn
))
9767 instantiate_decl (fn
);
9768 if (TYPE_SIZE (instantiation
))
9770 instantiated_something
= 1;
9775 if (TYPE_SIZE (instantiation
))
9776 /* If INSTANTIATION has been instantiated, then we don't
9777 need to consider it again in the future. */
9778 *t
= TREE_CHAIN (*t
);
9780 t
= &TREE_CHAIN (*t
);
9784 if (DECL_TEMPLATE_INSTANTIATION (instantiation
)
9785 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
9787 instantiation
= instantiate_decl (instantiation
);
9788 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
9790 instantiated_something
= 1;
9795 if (!DECL_TEMPLATE_INSTANTIATION (instantiation
)
9796 || DECL_TEMPLATE_INSTANTIATED (instantiation
))
9797 /* If INSTANTIATION has been instantiated, then we don't
9798 need to consider it again in the future. */
9799 *t
= TREE_CHAIN (*t
);
9801 t
= &TREE_CHAIN (*t
);
9806 /* Go through the things that are template instantiations if we are
9807 using guiding declarations. */
9808 t
= &maybe_templates
;
9815 fn
= TREE_VALUE (*t
);
9817 if (DECL_INITIAL (fn
))
9818 /* If the FN is already defined, then it was either already
9819 instantiated or, even though guiding declarations were
9820 allowed, a non-template definition was provided. */
9824 template = TREE_PURPOSE (*t
);
9825 args
= get_bindings (template, fn
, NULL_TREE
);
9826 fn
= instantiate_template (template, args
);
9827 instantiate_decl (fn
);
9831 /* Remove this entry from the chain. */
9832 *t
= TREE_CHAIN (*t
);
9834 maybe_template_tail
= t
;
9838 return instantiated_something
;
9841 /* Substitute ARGVEC into T, which is a TREE_LIST. In particular, it
9842 is an initializer list: the TREE_PURPOSEs are DECLs, and the
9843 TREE_VALUEs are initializer values. Used by instantiate_decl. */
9846 tsubst_expr_values (t
, argvec
)
9849 tree first
= NULL_TREE
;
9852 for (; t
; t
= TREE_CHAIN (t
))
9854 tree pur
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
9855 /*complain=*/1, NULL_TREE
);
9856 tree val
= tsubst_expr (TREE_VALUE (t
), argvec
, /*complain=*/1,
9858 *p
= build_tree_list (pur
, val
);
9859 p
= &TREE_CHAIN (*p
);
9867 if (current_function
)
9869 saved_trees
= tree_cons (NULL_TREE
, last_tree
, saved_trees
);
9870 last_tree
= NULL_TREE
;
9873 saved_trees
= tree_cons (NULL_TREE
, NULL_TREE
, saved_trees
);
9880 my_friendly_assert (saved_trees
!= NULL_TREE
, 0);
9882 if (current_function
)
9883 last_tree
= TREE_VALUE (saved_trees
);
9884 saved_trees
= TREE_CHAIN (saved_trees
);
9887 /* D is an undefined function declaration in the presence of templates with
9888 the same name, listed in FNS. If one of them can produce D as an
9889 instantiation, remember this so we can instantiate it at EOF if D has
9890 not been defined by that time. */
9893 add_maybe_template (d
, fns
)
9898 if (DECL_MAYBE_TEMPLATE (d
))
9901 t
= most_specialized (fns
, d
, NULL_TREE
);
9904 if (t
== error_mark_node
)
9906 cp_error ("ambiguous template instantiation for `%D'", d
);
9910 *maybe_template_tail
= tree_cons (t
, d
, NULL_TREE
);
9911 maybe_template_tail
= &TREE_CHAIN (*maybe_template_tail
);
9912 DECL_MAYBE_TEMPLATE (d
) = 1;
9915 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
9918 set_current_access_from_decl (decl
)
9921 if (TREE_PRIVATE (decl
))
9922 current_access_specifier
= access_private_node
;
9923 else if (TREE_PROTECTED (decl
))
9924 current_access_specifier
= access_protected_node
;
9926 current_access_specifier
= access_public_node
;
9929 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
9930 is the instantiation (which should have been created with
9931 start_enum) and ARGS are the template arguments to use. */
9934 tsubst_enum (tag
, newtag
, args
)
9941 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
9946 /* Note that in a template enum, the TREE_VALUE is the
9947 CONST_DECL, not the corresponding INTEGER_CST. */
9948 value
= tsubst_expr (DECL_INITIAL (TREE_VALUE (e
)),
9949 args
, /*complain=*/1,
9952 /* Give this enumeration constant the correct access. */
9953 set_current_access_from_decl (TREE_VALUE (e
));
9955 /* Actually build the enumerator itself. */
9956 elt
= build_enumerator (TREE_PURPOSE (e
), value
, newtag
);
9958 /* We save the enumerators we have built so far in the
9959 TYPE_VALUES so that if the enumeration constants for
9960 subsequent enumerators involve those for previous ones,
9961 tsubst_copy will be able to find them. */
9962 TREE_CHAIN (elt
) = TYPE_VALUES (newtag
);
9963 TYPE_VALUES (newtag
) = elt
;
9966 finish_enum (newtag
);
9969 /* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that
9970 is either an instantiation or specialization of a template
9974 set_mangled_name_for_template_decl (decl
)
9977 tree saved_namespace
;
9978 tree context
= NULL_TREE
;
9987 my_friendly_assert (TREE_CODE (decl
) == FUNCTION_DECL
, 0);
9988 my_friendly_assert (DECL_TEMPLATE_INFO (decl
) != NULL_TREE
, 0);
9990 /* The names of template functions must be mangled so as to indicate
9991 what template is being specialized with what template arguments.
9992 For example, each of the following three functions must get
9993 different mangled names:
9996 template <> void f<7>(int);
9997 template <> void f<8>(int); */
9999 targs
= DECL_TI_ARGS (decl
);
10000 if (uses_template_parms (targs
))
10001 /* This DECL is for a partial instantiation. There's no need to
10002 mangle the name of such an entity. */
10005 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
10006 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
10007 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
10009 /* There should be as many levels of arguments as there are levels
10011 my_friendly_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
), 0);
10013 /* We now compute the PARMS and RET_TYPE to give to
10014 build_decl_overload_real. The PARMS and RET_TYPE are the
10015 parameter and return types of the template, after all but the
10016 innermost template arguments have been substituted, not the
10017 parameter and return types of the function DECL. For example,
10020 template <class T> T f(T);
10022 both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'.
10023 A more subtle example is:
10025 template <class T> struct S { template <class U> void f(T, U); }
10027 Here, if DECL is `void S<int>::f(int, double)', PARMS should be
10028 {int, U}. Thus, the args that we want to subsitute into the
10029 return and parameter type for the function are those in TARGS,
10030 with the innermost level omitted. */
10031 fn_type
= TREE_TYPE (tmpl
);
10032 if (DECL_STATIC_FUNCTION_P (decl
))
10033 context
= DECL_CLASS_CONTEXT (decl
);
10035 if (parm_depth
== 1)
10036 /* No substitution is necessary. */
10043 /* Replace the innermost level of the TARGS with NULL_TREEs to
10044 let tsubst know not to subsitute for those parameters. */
10045 partial_args
= make_temp_vec (TREE_VEC_LENGTH (targs
));
10046 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
10047 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
10048 TMPL_ARGS_LEVEL (targs
, i
));
10049 SET_TMPL_ARGS_LEVEL (partial_args
,
10050 TMPL_ARGS_DEPTH (targs
),
10051 make_temp_vec (DECL_NTPARMS (tmpl
)));
10053 /* Now, do the (partial) substitution to figure out the
10054 appropriate function type. */
10055 fn_type
= tsubst (fn_type
, partial_args
, /*complain=*/1, NULL_TREE
);
10056 if (DECL_STATIC_FUNCTION_P (decl
))
10057 context
= tsubst (context
, partial_args
, /*complain=*/1, NULL_TREE
);
10059 /* Substitute into the template parameters to obtain the real
10060 innermost set of parameters. This step is important if the
10061 innermost set of template parameters contains value
10062 parameters whose types depend on outer template parameters. */
10063 TREE_VEC_LENGTH (partial_args
)--;
10064 tparms
= tsubst_template_parms (tparms
, partial_args
, /*complain=*/1);
10067 /* Now, get the innermost parameters and arguments, and figure out
10068 the parameter and return types. */
10069 tparms
= INNERMOST_TEMPLATE_PARMS (tparms
);
10070 targs
= innermost_args (targs
);
10071 ret_type
= TREE_TYPE (fn_type
);
10072 parm_types
= TYPE_ARG_TYPES (fn_type
);
10074 /* For a static member function, we generate a fake `this' pointer,
10075 for the purposes of mangling. This indicates of which class the
10076 function is a member. Because of:
10080 There shall not be a static and a nonstatic member function
10081 with the same name and the same parameter types
10083 we don't have to worry that this will result in a clash with a
10084 non-static member function. */
10085 if (DECL_STATIC_FUNCTION_P (decl
))
10086 parm_types
= hash_tree_chain (build_pointer_type (context
), parm_types
);
10088 /* There should be the same number of template parameters as
10089 template arguments. */
10090 my_friendly_assert (TREE_VEC_LENGTH (tparms
) == TREE_VEC_LENGTH (targs
),
10093 /* If the template is in a namespace, we need to put that into the
10094 mangled name. Unfortunately, build_decl_overload_real does not
10095 get the decl to mangle, so it relies on the current
10096 namespace. Therefore, we set that here temporarily. */
10097 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd', 980702);
10098 saved_namespace
= current_namespace
;
10099 current_namespace
= CP_DECL_CONTEXT (decl
);
10101 /* Actually set the DCL_ASSEMBLER_NAME. */
10102 DECL_ASSEMBLER_NAME (decl
)
10103 = build_decl_overload_real (DECL_NAME (decl
), parm_types
, ret_type
,
10105 DECL_FUNCTION_MEMBER_P (decl
)
10106 + DECL_CONSTRUCTOR_P (decl
));
10108 /* Restore the previously active namespace. */
10109 current_namespace
= saved_namespace
;