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 tree most_general_template PROTO((tree));
140 static void set_mangled_name_for_template_decl PROTO((tree));
141 static int template_class_depth_real PROTO((tree, int));
142 static tree tsubst_aggr_type PROTO((tree, tree, int, tree, int));
143 static tree tsubst_decl PROTO((tree, tree, tree, tree));
144 static tree tsubst_arg_types PROTO((tree, tree, int, tree));
145 static tree tsubst_function_type PROTO((tree, tree, int, tree));
146 static void check_specialization_scope PROTO((void));
147 static tree process_partial_specialization PROTO((tree));
148 static void set_current_access_from_decl PROTO((tree));
149 static void check_default_tmpl_args PROTO((tree, tree, int, int));
150 static tree tsubst_call_declarator_parms PROTO((tree, tree, int, tree));
151 static tree get_template_base_recursive PROTO((tree, tree,
152 tree, tree, tree, int));
153 static tree get_template_base PROTO((tree, tree, tree, tree));
154 static tree try_class_unification PROTO((tree, tree, tree, tree));
155 static int coerce_template_template_parms PROTO((tree, tree, int,
157 static tree determine_specialization PROTO((tree, tree, tree *, int));
158 static int template_args_equal PROTO((tree, tree));
159 static void print_template_context PROTO((int));
160 static void tsubst_default_arguments PROTO((tree));
162 /* We use TREE_VECs to hold template arguments. If there is only one
163 level of template arguments, then the TREE_VEC contains the
164 arguments directly. If there is more than one level of template
165 arguments, then each entry in the TREE_VEC is itself a TREE_VEC,
166 containing the template arguments for a single level. The first
167 entry in the outer TREE_VEC is the outermost level of template
168 parameters; the last is the innermost.
170 It is incorrect to ever form a template argument vector containing
171 only one level of arguments, but which is a TREE_VEC containing as
172 its only entry the TREE_VEC for that level. */
174 /* Non-zero if the template arguments is actually a vector of vectors,
175 rather than just a vector. */
176 #define TMPL_ARGS_HAVE_MULTIPLE_LEVELS(NODE) \
178 && TREE_CODE (NODE) == TREE_VEC \
179 && TREE_VEC_LENGTH (NODE) > 0 \
180 && TREE_VEC_ELT (NODE, 0) != NULL_TREE \
181 && TREE_CODE (TREE_VEC_ELT (NODE, 0)) == TREE_VEC)
183 /* The depth of a template argument vector. When called directly by
184 the parser, we use a TREE_LIST rather than a TREE_VEC to represent
185 template arguments. In fact, we may even see NULL_TREE if there
186 are no template arguments. In both of those cases, there is only
187 one level of template arguments. */
188 #define TMPL_ARGS_DEPTH(NODE) \
189 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (NODE) ? TREE_VEC_LENGTH (NODE) : 1)
191 /* The LEVELth level of the template ARGS. Note that template
192 parameter levels are indexed from 1, not from 0. */
193 #define TMPL_ARGS_LEVEL(ARGS, LEVEL) \
194 (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (ARGS) \
195 ? TREE_VEC_ELT ((ARGS), (LEVEL) - 1) : ARGS)
197 /* Set the LEVELth level of the template ARGS to VAL. This macro does
198 not work with single-level argument vectors. */
199 #define SET_TMPL_ARGS_LEVEL(ARGS, LEVEL, VAL) \
200 (TREE_VEC_ELT ((ARGS), (LEVEL) - 1) = (VAL))
202 /* Accesses the IDXth parameter in the LEVELth level of the ARGS. */
203 #define TMPL_ARG(ARGS, LEVEL, IDX) \
204 (TREE_VEC_ELT (TMPL_ARGS_LEVEL (ARGS, LEVEL), IDX))
206 /* Set the IDXth element in the LEVELth level of ARGS to VAL. This
207 macro does not work with single-level argument vectors. */
208 #define SET_TMPL_ARG(ARGS, LEVEL, IDX, VAL) \
209 (TREE_VEC_ELT (TREE_VEC_ELT ((ARGS), (LEVEL) - 1), (IDX)) = (VAL))
211 /* Given a single level of template arguments in NODE, return the
212 number of arguments. */
213 #define NUM_TMPL_ARGS(NODE) \
214 ((NODE) == NULL_TREE ? 0 \
215 : (TREE_CODE (NODE) == TREE_VEC \
216 ? TREE_VEC_LENGTH (NODE) : list_length (NODE)))
218 /* The number of levels of template parameters given by NODE. */
219 #define TMPL_PARMS_DEPTH(NODE) \
220 (TREE_INT_CST_HIGH (TREE_PURPOSE (NODE)))
222 /* Called once to initialize pt.c. */
227 ggc_add_tree_root (&pending_templates, 1);
228 ggc_add_tree_root (&maybe_templates, 1);
229 ggc_add_tree_root (&saved_trees, 1);
232 /* Do any processing required when DECL (a member template declaration
233 using TEMPLATE_PARAMETERS as its innermost parameter list) is
234 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
235 it is a specialization, in which case the DECL itself is returned. */
238 finish_member_template_decl (decl)
241 if (decl == NULL_TREE || decl == void_type_node)
243 else if (decl == error_mark_node)
244 /* By returning NULL_TREE, the parser will just ignore this
245 declaration. We have already issued the error. */
247 else if (TREE_CODE (decl) == TREE_LIST)
249 /* Assume that the class is the only declspec. */
250 decl = TREE_VALUE (decl);
251 if (IS_AGGR_TYPE (decl) && CLASSTYPE_TEMPLATE_INFO (decl)
252 && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl))
254 tree tmpl = CLASSTYPE_TI_TEMPLATE (decl);
255 check_member_template (tmpl);
260 else if (DECL_TEMPLATE_INFO (decl))
262 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
264 check_member_template (DECL_TI_TEMPLATE (decl));
265 return DECL_TI_TEMPLATE (decl);
271 cp_error ("invalid member template declaration `%D'", decl);
273 return error_mark_node;
276 /* Returns the template nesting level of the indicated class TYPE.
286 A<T>::B<U> has depth two, while A<T> has depth one.
287 Both A<T>::B<int> and A<int>::B<U> have depth one, if
288 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
291 This function is guaranteed to return 0 if passed NULL_TREE so
292 that, for example, `template_class_depth (current_class_type)' is
296 template_class_depth_real (type, count_specializations)
298 int count_specializations;
303 type && TREE_CODE (type) != NAMESPACE_DECL;
304 type = (TREE_CODE (type) == FUNCTION_DECL)
305 ? DECL_REAL_CONTEXT (type) : TYPE_CONTEXT (type))
307 if (TREE_CODE (type) != FUNCTION_DECL)
309 if (CLASSTYPE_TEMPLATE_INFO (type)
310 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
311 && ((count_specializations
312 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
313 || uses_template_parms (CLASSTYPE_TI_ARGS (type))))
318 if (DECL_TEMPLATE_INFO (type)
319 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
320 && ((count_specializations
321 && DECL_TEMPLATE_SPECIALIZATION (type))
322 || uses_template_parms (DECL_TI_ARGS (type))))
330 /* Returns the template nesting level of the indicated class TYPE.
331 Like template_class_depth_real, but instantiations do not count in
335 template_class_depth (type)
338 return template_class_depth_real (type, /*count_specializations=*/0);
341 /* Returns 1 if processing DECL as part of do_pending_inlines
342 needs us to push template parms. */
345 inline_needs_template_parms (decl)
348 if (! DECL_TEMPLATE_INFO (decl))
351 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
352 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
355 /* Subroutine of maybe_begin_member_template_processing.
356 Push the template parms in PARMS, starting from LEVELS steps into the
357 chain, and ending at the beginning, since template parms are listed
361 push_inline_template_parms_recursive (parmlist, levels)
365 tree parms = TREE_VALUE (parmlist);
369 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
371 ++processing_template_decl;
372 current_template_parms
373 = tree_cons (build_int_2 (0, processing_template_decl),
374 parms, current_template_parms);
375 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
378 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
380 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
381 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (parm)) == 'd', 0);
383 switch (TREE_CODE (parm))
392 /* Make a CONST_DECL as is done in process_template_parm.
393 It is ugly that we recreate this here; the original
394 version built in process_template_parm is no longer
396 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
398 SET_DECL_ARTIFICIAL (decl);
399 DECL_INITIAL (decl) = DECL_INITIAL (parm);
400 DECL_TEMPLATE_PARM_P (decl) = 1;
406 my_friendly_abort (0);
411 /* Restore the template parameter context for a member template or
412 a friend template defined in a class definition. */
415 maybe_begin_member_template_processing (decl)
421 if (inline_needs_template_parms (decl))
423 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
424 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
426 if (DECL_TEMPLATE_SPECIALIZATION (decl))
429 parms = TREE_CHAIN (parms);
432 push_inline_template_parms_recursive (parms, levels);
435 /* Remember how many levels of template parameters we pushed so that
436 we can pop them later. */
437 if (!inline_parm_levels)
438 VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels");
439 if (inline_parm_levels_used == inline_parm_levels->num_elements)
440 VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used);
441 VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels;
442 ++inline_parm_levels_used;
445 /* Undo the effects of begin_member_template_processing. */
448 maybe_end_member_template_processing ()
452 if (!inline_parm_levels_used)
455 --inline_parm_levels_used;
457 i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used);
460 --processing_template_decl;
461 current_template_parms = TREE_CHAIN (current_template_parms);
466 /* Returns non-zero iff T is a member template function. We must be
469 template <class T> class C { void f(); }
471 Here, f is a template function, and a member, but not a member
472 template. This function does not concern itself with the origin of
473 T, only its present state. So if we have
475 template <class T> class C { template <class U> void f(U); }
477 then neither C<int>::f<char> nor C<T>::f<double> is considered
478 to be a member template. But, `template <class U> void
479 C<int>::f(U)' is considered a member template. */
482 is_member_template (t)
485 if (!DECL_FUNCTION_TEMPLATE_P (t))
486 /* Anything that isn't a function or a template function is
487 certainly not a member template. */
490 /* A local class can't have member templates. */
491 if (hack_decl_function_context (t))
494 return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t))
495 /* If there are more levels of template parameters than
496 there are template classes surrounding the declaration,
497 then we have a member template. */
498 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) >
499 template_class_depth (DECL_CLASS_CONTEXT (t))));
503 /* Returns non-zero iff T is a member template class. See
504 is_member_template for a description of what precisely constitutes
505 a member template. */
508 is_member_template_class (t)
511 if (!DECL_CLASS_TEMPLATE_P (t))
512 /* Anything that isn't a class template, is certainly not a member
516 if (!DECL_CLASS_SCOPE_P (t))
517 /* Anything whose context isn't a class type is surely not a
521 /* If there are more levels of template parameters than there are
522 template classes surrounding the declaration, then we have a
524 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) >
525 template_class_depth (DECL_CONTEXT (t)));
529 /* Return a new template argument vector which contains all of ARGS,
530 but has as its innermost set of arguments the EXTRA_ARGS. The
531 resulting vector will be built on a temporary obstack, and so must
532 be explicitly copied to the permanent obstack, if required. */
535 add_to_template_args (args, extra_args)
544 extra_depth = TMPL_ARGS_DEPTH (extra_args);
545 new_args = make_temp_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
547 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
548 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
550 for (j = 1; j <= extra_depth; ++j, ++i)
551 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
556 /* Like add_to_template_args, but only the outermost ARGS are added to
557 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
558 (EXTRA_ARGS) levels are added. This function is used to combine
559 the template arguments from a partial instantiation with the
560 template arguments used to attain the full instantiation from the
561 partial instantiation. */
564 add_outermost_template_args (args, extra_args)
570 /* If there are more levels of EXTRA_ARGS than there are ARGS,
571 something very fishy is going on. */
572 my_friendly_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args),
575 /* If *all* the new arguments will be the EXTRA_ARGS, just return
577 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
580 /* For the moment, we make ARGS look like it contains fewer levels. */
581 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
583 new_args = add_to_template_args (args, extra_args);
585 /* Now, we restore ARGS to its full dimensions. */
586 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
591 /* We've got a template header coming up; push to a new level for storing
595 begin_template_parm_list ()
597 /* We use a non-tag-transparent scope here, which causes pushtag to
598 put tags in this scope, rather than in the enclosing class or
599 namespace scope. This is the right thing, since we want
600 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
601 global template class, push_template_decl handles putting the
602 TEMPLATE_DECL into top-level scope. For a nested template class,
605 template <class T> struct S1 {
606 template <class T> struct S2 {};
609 pushtag contains special code to call pushdecl_with_scope on the
610 TEMPLATE_DECL for S2. */
612 declare_pseudo_global_level ();
613 ++processing_template_decl;
614 ++processing_template_parmlist;
615 note_template_header (0);
618 /* This routine is called when a specialization is declared. If it is
619 illegal to declare a specialization here, an error is reported. */
622 check_specialization_scope ()
624 tree scope = current_scope ();
628 An explicit specialization shall be declared in the namespace of
629 which the template is a member, or, for member templates, in the
630 namespace of which the enclosing class or enclosing class
631 template is a member. An explicit specialization of a member
632 function, member class or static data member of a class template
633 shall be declared in the namespace of which the class template
635 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
636 cp_error ("explicit specialization in non-namespace scope `%D'",
641 In an explicit specialization declaration for a member of a class
642 template or a member template that appears in namespace scope,
643 the member template and some of its enclosing class templates may
644 remain unspecialized, except that the declaration shall not
645 explicitly specialize a class member template if its enclosing
646 class templates are not explicitly specialized as well. */
647 if (current_template_parms)
648 cp_error ("enclosing class templates are not explicitly specialized");
651 /* We've just seen template <>. */
654 begin_specialization ()
656 note_template_header (1);
657 check_specialization_scope ();
660 /* Called at then end of processing a declaration preceeded by
664 end_specialization ()
666 reset_specialization ();
669 /* Any template <>'s that we have seen thus far are not referring to a
670 function specialization. */
673 reset_specialization ()
675 processing_specialization = 0;
676 template_header_count = 0;
679 /* We've just seen a template header. If SPECIALIZATION is non-zero,
680 it was of the form template <>. */
683 note_template_header (specialization)
686 processing_specialization = specialization;
687 template_header_count++;
690 /* We're beginning an explicit instantiation. */
693 begin_explicit_instantiation ()
695 ++processing_explicit_instantiation;
700 end_explicit_instantiation ()
702 my_friendly_assert(processing_explicit_instantiation > 0, 0);
703 --processing_explicit_instantiation;
706 /* The TYPE is being declared. If it is a template type, that means it
707 is a partial specialization. Do appropriate error-checking. */
710 maybe_process_partial_specialization (type)
713 if (IS_AGGR_TYPE (type) && CLASSTYPE_USE_TEMPLATE (type))
715 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
716 && TYPE_SIZE (type) == NULL_TREE)
718 if (current_namespace
719 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
721 cp_pedwarn ("specializing `%#T' in different namespace", type);
722 cp_pedwarn_at (" from definition of `%#D'",
723 CLASSTYPE_TI_TEMPLATE (type));
725 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
726 if (processing_template_decl)
727 push_template_decl (TYPE_MAIN_DECL (type));
729 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
730 cp_error ("specialization of `%T' after instantiation", type);
732 else if (processing_specialization)
733 cp_error ("explicit specialization of non-template `%T'", type);
736 /* Retrieve the specialization (in the sense of [temp.spec] - a
737 specialization is either an instantiation or an explicit
738 specialization) of TMPL for the given template ARGS. If there is
739 no such specialization, return NULL_TREE. The ARGS are a vector of
740 arguments, or a vector of vectors of arguments, in the case of
741 templates with more than one level of parameters. */
744 retrieve_specialization (tmpl, args)
750 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
752 /* There should be as many levels of arguments as there are
753 levels of parameters. */
754 my_friendly_assert (TMPL_ARGS_DEPTH (args)
755 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)),
758 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
761 if (comp_template_args (TREE_PURPOSE (s), args))
762 return TREE_VALUE (s);
767 /* Like retrieve_speciailization, but for local declarations. FN is
768 the function in which we are looking for an instantiation. */
771 retrieve_local_specialization (tmpl, fn)
775 tree s = purpose_member (fn, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
776 return s ? TREE_VALUE (s) : NULL_TREE;
779 /* Returns non-zero iff DECL is a specialization of TMPL. */
782 is_specialization_of (decl, tmpl)
788 if (TREE_CODE (decl) == FUNCTION_DECL)
792 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
798 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 0);
800 for (t = TREE_TYPE (decl);
802 t = CLASSTYPE_USE_TEMPLATE (t)
803 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
804 if (same_type_p (TYPE_MAIN_VARIANT (t),
805 TYPE_MAIN_VARIANT (TREE_TYPE (tmpl))))
812 /* Register the specialization SPEC as a specialization of TMPL with
813 the indicated ARGS. Returns SPEC, or an equivalent prior
814 declaration, if available. */
817 register_specialization (spec, tmpl, args)
824 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
826 if (TREE_CODE (spec) == FUNCTION_DECL
827 && uses_template_parms (DECL_TI_ARGS (spec)))
828 /* This is the FUNCTION_DECL for a partial instantiation. Don't
829 register it; we want the corresponding TEMPLATE_DECL instead.
830 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
831 the more obvious `uses_template_parms (spec)' to avoid problems
832 with default function arguments. In particular, given
835 template <class T> void f(T t1, T t = T())
837 the default argument expression is not substituted for in an
838 instantiation unless and until it is actually needed. */
841 /* There should be as many levels of arguments as there are
842 levels of parameters. */
843 my_friendly_assert (TMPL_ARGS_DEPTH (args)
844 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)),
847 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
851 tree fn = TREE_VALUE (s);
853 /* We can sometimes try to re-register a specialization that we've
854 already got. In particular, regenerate_decl_from_template
855 calls duplicate_decls which will update the specialization
856 list. But, we'll still get called again here anyhow. It's
857 more convenient to simply allow this than to try to prevent it. */
860 else if (comp_template_args (TREE_PURPOSE (s), args))
862 if (DECL_TEMPLATE_SPECIALIZATION (spec))
864 if (DECL_TEMPLATE_INSTANTIATION (fn))
867 || DECL_EXPLICIT_INSTANTIATION (fn))
869 cp_error ("specialization of %D after instantiation",
875 /* This situation should occur only if the first
876 specialization is an implicit instantiation,
877 the second is an explicit specialization, and
878 the implicit instantiation has not yet been
879 used. That situation can occur if we have
880 implicitly instantiated a member function and
881 then specialized it later.
883 We can also wind up here if a friend
884 declaration that looked like an instantiation
885 turns out to be a specialization:
887 template <class T> void foo(T);
888 class S { friend void foo<>(int) };
889 template <> void foo(int);
891 We transform the existing DECL in place so that
892 any pointers to it become pointers to the
895 If there was a definition for the template, but
896 not for the specialization, we want this to
897 look as if there is no definition, and vice
899 DECL_INITIAL (fn) = NULL_TREE;
900 duplicate_decls (spec, fn);
905 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
907 duplicate_decls (spec, fn);
914 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
915 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
920 /* Unregister the specialization SPEC as a specialization of TMPL.
921 Returns nonzero if the SPEC was listed as a specialization of
925 unregister_specialization (spec, tmpl)
931 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
933 s = &TREE_CHAIN (*s))
934 if (TREE_VALUE (*s) == spec)
936 *s = TREE_CHAIN (*s);
943 /* Like register_specialization, but for local declarations. FN is
944 the function in which we are registering SPEC, an instantiation of
948 register_local_specialization (spec, tmpl, fn)
953 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
954 = tree_cons (fn, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
959 /* Print the list of candidate FNS in an error message. */
962 print_candidates (fns)
967 const char *str = "candidates are:";
969 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
973 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
974 cp_error_at ("%s %+#D", str, OVL_CURRENT (f));
979 /* Returns the template (one of the functions given by TEMPLATE_ID)
980 which can be specialized to match the indicated DECL with the
981 explicit template args given in TEMPLATE_ID. The DECL may be
982 NULL_TREE if none is available. In that case, the functions in
983 TEMPLATE_ID are non-members.
985 If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a
986 specialization of a member template.
988 The template args (those explicitly specified and those deduced)
989 are output in a newly created vector *TARGS_OUT.
991 If it is impossible to determine the result, an error message is
992 issued. The error_mark_node is returned to indicate failure. */
995 determine_specialization (template_id, decl, targs_out,
996 need_member_template)
1000 int need_member_template;
1004 tree explicit_targs;
1005 tree candidates = NULL_TREE;
1006 tree templates = NULL_TREE;
1008 *targs_out = NULL_TREE;
1010 if (template_id == error_mark_node)
1011 return error_mark_node;
1013 fns = TREE_OPERAND (template_id, 0);
1014 explicit_targs = TREE_OPERAND (template_id, 1);
1016 if (fns == error_mark_node)
1017 return error_mark_node;
1019 /* Check for baselinks. */
1020 if (BASELINK_P (fns))
1021 fns = TREE_VALUE (fns);
1023 if (!is_overloaded_fn (fns))
1025 cp_error ("`%D' is not a function template", fns);
1026 return error_mark_node;
1029 for (; fns; fns = OVL_NEXT (fns))
1033 tree fn = OVL_CURRENT (fns);
1035 if (TREE_CODE (fn) == TEMPLATE_DECL)
1036 /* DECL might be a specialization of FN. */
1038 else if (need_member_template)
1039 /* FN is an ordinary member function, and we need a
1040 specialization of a member template. */
1042 else if (TREE_CODE (fn) != FUNCTION_DECL)
1043 /* We can get IDENTIFIER_NODEs here in certain erroneous
1046 else if (!DECL_FUNCTION_MEMBER_P (fn))
1047 /* This is just an ordinary non-member function. Nothing can
1048 be a specialization of that. */
1052 tree decl_arg_types;
1054 /* This is an ordinary member function. However, since
1055 we're here, we can assume it's enclosing class is a
1056 template class. For example,
1058 template <typename T> struct S { void f(); };
1059 template <> void S<int>::f() {}
1061 Here, S<int>::f is a non-template, but S<int> is a
1062 template class. If FN has the same type as DECL, we
1063 might be in business. */
1064 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1065 TREE_TYPE (TREE_TYPE (fn))))
1066 /* The return types differ. */
1069 /* Adjust the type of DECL in case FN is a static member. */
1070 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1071 if (DECL_STATIC_FUNCTION_P (fn)
1072 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1073 decl_arg_types = TREE_CHAIN (decl_arg_types);
1075 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1078 candidates = tree_cons (NULL_TREE, fn, candidates);
1083 /* See whether this function might be a specialization of this
1085 targs = get_bindings (tmpl, decl, explicit_targs);
1088 /* We cannot deduce template arguments that when used to
1089 specialize TMPL will produce DECL. */
1092 /* Save this template, and the arguments deduced. */
1093 templates = tree_cons (targs, tmpl, templates);
1096 if (templates && TREE_CHAIN (templates))
1102 It is possible for a specialization with a given function
1103 signature to be instantiated from more than one function
1104 template. In such cases, explicit specification of the
1105 template arguments must be used to uniquely identify the
1106 function template specialization being specialized.
1108 Note that here, there's no suggestion that we're supposed to
1109 determine which of the candidate templates is most
1110 specialized. However, we, also have:
1114 Partial ordering of overloaded function template
1115 declarations is used in the following contexts to select
1116 the function template to which a function template
1117 specialization refers:
1119 -- when an explicit specialization refers to a function
1122 So, we do use the partial ordering rules, at least for now.
1123 This extension can only serve to make illegal programs legal,
1124 so it's safe. And, there is strong anecdotal evidence that
1125 the committee intended the partial ordering rules to apply;
1126 the EDG front-end has that behavior, and John Spicer claims
1127 that the committee simply forgot to delete the wording in
1128 [temp.expl.spec]. */
1129 tree tmpl = most_specialized (templates, decl, explicit_targs);
1130 if (tmpl && tmpl != error_mark_node)
1132 targs = get_bindings (tmpl, decl, explicit_targs);
1133 templates = tree_cons (targs, tmpl, NULL_TREE);
1137 if (templates == NULL_TREE && candidates == NULL_TREE)
1139 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
1141 return error_mark_node;
1143 else if ((templates && TREE_CHAIN (templates))
1144 || (candidates && TREE_CHAIN (candidates))
1145 || (templates && candidates))
1147 cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1149 chainon (candidates, templates);
1150 print_candidates (candidates);
1151 return error_mark_node;
1154 /* We have one, and exactly one, match. */
1157 /* It was a specialization of an ordinary member function in a
1159 *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates)));
1160 return DECL_TI_TEMPLATE (TREE_VALUE (candidates));
1163 /* It was a specialization of a template. */
1164 targs = DECL_TI_ARGS (DECL_RESULT (TREE_VALUE (templates)));
1165 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1167 *targs_out = copy_node (targs);
1168 SET_TMPL_ARGS_LEVEL (*targs_out,
1169 TMPL_ARGS_DEPTH (*targs_out),
1170 TREE_PURPOSE (templates));
1173 *targs_out = TREE_PURPOSE (templates);
1174 return TREE_VALUE (templates);
1177 /* Check to see if the function just declared, as indicated in
1178 DECLARATOR, and in DECL, is a specialization of a function
1179 template. We may also discover that the declaration is an explicit
1180 instantiation at this point.
1182 Returns DECL, or an equivalent declaration that should be used
1183 instead if all goes well. Issues an error message if something is
1184 amiss. Returns error_mark_node if the error is not easily
1187 FLAGS is a bitmask consisting of the following flags:
1189 2: The function has a definition.
1190 4: The function is a friend.
1192 The TEMPLATE_COUNT is the number of references to qualifying
1193 template classes that appeared in the name of the function. For
1196 template <class T> struct S { void f(); };
1199 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1200 classes are not counted in the TEMPLATE_COUNT, so that in
1202 template <class T> struct S {};
1203 template <> struct S<int> { void f(); }
1204 template <> void S<int>::f();
1206 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1207 illegal; there should be no template <>.)
1209 If the function is a specialization, it is marked as such via
1210 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1211 is set up correctly, and it is added to the list of specializations
1212 for that template. */
1215 check_explicit_specialization (declarator, decl, template_count, flags)
1221 int have_def = flags & 2;
1222 int is_friend = flags & 4;
1223 int specialization = 0;
1224 int explicit_instantiation = 0;
1225 int member_specialization = 0;
1227 tree ctype = DECL_CLASS_CONTEXT (decl);
1228 tree dname = DECL_NAME (decl);
1230 if (processing_specialization)
1232 /* The last template header was of the form template <>. */
1234 if (template_header_count > template_count)
1236 /* There were more template headers than qualifying template
1238 if (template_header_count - template_count > 1)
1239 /* There shouldn't be that many template parameter lists.
1240 There can be at most one parameter list for every
1241 qualifying class, plus one for the function itself. */
1242 cp_error ("too many template parameter lists in declaration of `%D'", decl);
1244 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1246 member_specialization = 1;
1250 else if (template_header_count == template_count)
1252 /* The counts are equal. So, this might be a
1253 specialization, but it is not a specialization of a
1254 member template. It might be something like
1256 template <class T> struct S {
1260 void S<int>::f(int i) {} */
1262 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1266 /* This cannot be an explicit specialization. There are not
1267 enough headers for all of the qualifying classes. For
1268 example, we might have:
1271 void S<int>::T<char>::f();
1273 But, we're missing another template <>. */
1274 cp_error("too few template parameter lists in declaration of `%D'", decl);
1278 else if (processing_explicit_instantiation)
1280 if (template_header_count)
1281 cp_error ("template parameter list used in explicit instantiation");
1284 cp_error ("definition provided for explicit instantiation");
1286 explicit_instantiation = 1;
1288 else if (ctype != NULL_TREE
1289 && !TYPE_BEING_DEFINED (ctype)
1290 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)
1293 /* This case catches outdated code that looks like this:
1295 template <class T> struct S { void f(); };
1296 void S<int>::f() {} // Missing template <>
1298 We disable this check when the type is being defined to
1299 avoid complaining about default compiler-generated
1300 constructors, destructors, and assignment operators.
1301 Since the type is an instantiation, not a specialization,
1302 these are the only functions that can be defined before
1303 the class is complete. */
1306 template <class T> void S<int>::f() {}
1308 if (template_header_count)
1310 cp_error ("template parameters specified in specialization");
1316 ("explicit specialization not preceded by `template <>'");
1318 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1320 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1323 /* This could be something like:
1325 template <class T> void f(T);
1326 class S { friend void f<>(int); } */
1330 /* This case handles bogus declarations like template <>
1331 template <class T> void f<int>(); */
1333 cp_error ("template-id `%D' in declaration of primary template",
1339 if (specialization || member_specialization)
1341 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1342 for (; t; t = TREE_CHAIN (t))
1343 if (TREE_PURPOSE (t))
1346 ("default argument specified in explicit specialization");
1349 if (current_lang_name == lang_name_c)
1350 cp_error ("template specialization with C linkage");
1353 if (specialization || member_specialization || explicit_instantiation)
1355 tree tmpl = NULL_TREE;
1356 tree targs = NULL_TREE;
1358 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1359 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1363 my_friendly_assert (TREE_CODE (declarator) == IDENTIFIER_NODE,
1366 fns = IDENTIFIER_NAMESPACE_VALUE (dname);
1371 lookup_template_function (fns, NULL_TREE);
1374 if (declarator == error_mark_node)
1375 return error_mark_node;
1377 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1379 if (!explicit_instantiation)
1380 /* A specialization in class scope. This is illegal,
1381 but the error will already have been flagged by
1382 check_specialization_scope. */
1383 return error_mark_node;
1386 /* It's not legal to write an explicit instantiation in
1389 class C { template void f(); }
1391 This case is caught by the parser. However, on
1394 template class C { void f(); };
1396 (which is illegal) we can get here. The error will be
1403 else if (TREE_CODE (TREE_OPERAND (declarator, 0)) == LOOKUP_EXPR)
1405 /* A friend declaration. We can't do much, because we don't
1406 know what this resolves to, yet. */
1407 my_friendly_assert (is_friend != 0, 0);
1408 my_friendly_assert (!explicit_instantiation, 0);
1409 SET_DECL_IMPLICIT_INSTANTIATION (decl);
1412 else if (ctype != NULL_TREE
1413 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
1416 /* Find the list of functions in ctype that have the same
1417 name as the declared function. */
1418 tree name = TREE_OPERAND (declarator, 0);
1419 tree fns = NULL_TREE;
1422 if (name == constructor_name (ctype)
1423 || name == constructor_name_full (ctype))
1425 int is_constructor = DECL_CONSTRUCTOR_P (decl);
1427 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
1428 : !TYPE_HAS_DESTRUCTOR (ctype))
1430 /* From [temp.expl.spec]:
1432 If such an explicit specialization for the member
1433 of a class template names an implicitly-declared
1434 special member function (clause _special_), the
1435 program is ill-formed.
1437 Similar language is found in [temp.explicit]. */
1438 cp_error ("specialization of implicitly-declared special member function");
1439 return error_mark_node;
1442 name = is_constructor ? ctor_identifier : dtor_identifier;
1445 if (!IDENTIFIER_TYPENAME_P (name))
1447 idx = lookup_fnfields_1 (ctype, name);
1449 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), idx);
1455 /* For a type-conversion operator, we cannot do a
1456 name-based lookup. We might be looking for `operator
1457 int' which will be a specialization of `operator T'.
1458 So, we find *all* the conversion operators, and then
1459 select from them. */
1462 methods = CLASSTYPE_METHOD_VEC (ctype);
1464 for (idx = 2; idx < TREE_VEC_LENGTH (methods); ++idx)
1466 tree ovl = TREE_VEC_ELT (methods, idx);
1468 if (!ovl || !DECL_CONV_FN_P (OVL_CURRENT (ovl)))
1469 /* There are no more conversion functions. */
1472 /* Glue all these conversion functions together
1473 with those we already have. */
1474 for (; ovl; ovl = OVL_NEXT (ovl))
1475 fns = ovl_cons (OVL_CURRENT (ovl), fns);
1479 if (fns == NULL_TREE)
1481 cp_error ("no member function `%D' declared in `%T'",
1483 return error_mark_node;
1486 TREE_OPERAND (declarator, 0) = fns;
1489 /* Figure out what exactly is being specialized at this point.
1490 Note that for an explicit instantiation, even one for a
1491 member function, we cannot tell apriori whether the
1492 instantiation is for a member template, or just a member
1493 function of a template class. Even if a member template is
1494 being instantiated, the member template arguments may be
1495 elided if they can be deduced from the rest of the
1497 tmpl = determine_specialization (declarator, decl,
1499 member_specialization);
1501 if (!tmpl || tmpl == error_mark_node)
1502 /* We couldn't figure out what this declaration was
1504 return error_mark_node;
1507 tree gen_tmpl = most_general_template (tmpl);
1509 if (explicit_instantiation)
1511 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1512 is done by do_decl_instantiation later. */
1514 int arg_depth = TMPL_ARGS_DEPTH (targs);
1515 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
1517 if (arg_depth > parm_depth)
1519 /* If TMPL is not the most general template (for
1520 example, if TMPL is a friend template that is
1521 injected into namespace scope), then there will
1522 be too many levels fo TARGS. Remove some of them
1527 new_targs = make_temp_vec (parm_depth);
1528 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
1529 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
1530 = TREE_VEC_ELT (targs, i);
1534 decl = instantiate_template (tmpl, targs);
1538 /* If we though that the DECL was a member function, but it
1539 turns out to be specializing a static member function,
1540 make DECL a static member function as well. */
1541 if (DECL_STATIC_FUNCTION_P (tmpl)
1542 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1544 revert_static_member_fn (&decl, 0, 0);
1545 last_function_parms = TREE_CHAIN (last_function_parms);
1548 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1549 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
1551 /* Mangle the function name appropriately. Note that we do
1552 not mangle specializations of non-template member
1553 functions of template classes, e.g. with
1555 template <class T> struct S { void f(); }
1557 and given the specialization
1559 template <> void S<int>::f() {}
1561 we do not mangle S<int>::f() here. That's because it's
1562 just an ordinary member function and doesn't need special
1563 treatment. We do this here so that the ordinary,
1564 non-template, name-mangling algorith will not be used
1566 if ((is_member_template (tmpl) || ctype == NULL_TREE)
1567 && name_mangling_version >= 1)
1568 set_mangled_name_for_template_decl (decl);
1570 if (is_friend && !have_def)
1571 /* This is not really a declaration of a specialization.
1572 It's just the name of an instantiation. But, it's not
1573 a request for an instantiation, either. */
1574 SET_DECL_IMPLICIT_INSTANTIATION (decl);
1576 /* Register this specialization so that we can find it
1578 decl = register_specialization (decl, gen_tmpl, targs);
1585 /* TYPE is being declared. Verify that the use of template headers
1586 and such is reasonable. Issue error messages if not. */
1589 maybe_check_template_type (type)
1592 if (template_header_count)
1594 /* We are in the scope of some `template <...>' header. */
1597 = template_class_depth_real (TYPE_CONTEXT (type),
1598 /*count_specializations=*/1);
1600 if (template_header_count <= context_depth)
1601 /* This is OK; the template headers are for the context. We
1602 are actually too lenient here; like
1603 check_explicit_specialization we should consider the number
1604 of template types included in the actual declaration. For
1607 template <class T> struct S {
1608 template <class U> template <class V>
1614 template <class T> struct S {
1615 template <class U> struct I;
1618 template <class T> template <class U.
1623 else if (template_header_count > context_depth + 1)
1624 /* There are two many template parameter lists. */
1625 cp_error ("too many template parameter lists in declaration of `%T'", type);
1629 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1630 parameters. These are represented in the same format used for
1631 DECL_TEMPLATE_PARMS. */
1633 int comp_template_parms (parms1, parms2)
1640 if (parms1 == parms2)
1643 for (p1 = parms1, p2 = parms2;
1644 p1 != NULL_TREE && p2 != NULL_TREE;
1645 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
1647 tree t1 = TREE_VALUE (p1);
1648 tree t2 = TREE_VALUE (p2);
1651 my_friendly_assert (TREE_CODE (t1) == TREE_VEC, 0);
1652 my_friendly_assert (TREE_CODE (t2) == TREE_VEC, 0);
1654 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
1657 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
1659 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
1660 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
1662 if (TREE_CODE (parm1) != TREE_CODE (parm2))
1665 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
1667 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
1672 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
1673 /* One set of parameters has more parameters lists than the
1680 /* Complain if DECL shadows a template parameter.
1682 [temp.local]: A template-parameter shall not be redeclared within its
1683 scope (including nested scopes). */
1686 check_template_shadow (decl)
1691 /* If we're not in a template, we can't possibly shadow a template
1693 if (!current_template_parms)
1696 /* Figure out what we're shadowing. */
1697 if (TREE_CODE (decl) == OVERLOAD)
1698 decl = OVL_CURRENT (decl);
1699 olddecl = IDENTIFIER_VALUE (DECL_NAME (decl));
1701 /* If there's no previous binding for this name, we're not shadowing
1702 anything, let alone a template parameter. */
1706 /* If we're not shadowing a template parameter, we're done. Note
1707 that OLDDECL might be an OVERLOAD (or perhaps even an
1708 ERROR_MARK), so we can't just blithely assume it to be a _DECL
1710 if (TREE_CODE_CLASS (TREE_CODE (olddecl)) != 'd'
1711 || !DECL_TEMPLATE_PARM_P (olddecl))
1714 /* We check for decl != olddecl to avoid bogus errors for using a
1715 name inside a class. We check TPFI to avoid duplicate errors for
1716 inline member templates. */
1718 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
1721 cp_error_at ("declaration of `%#D'", decl);
1722 cp_error_at (" shadows template parm `%#D'", olddecl);
1725 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1726 ORIG_LEVEL, DECL, and TYPE. */
1729 build_template_parm_index (index, level, orig_level, decl, type)
1736 tree t = make_node (TEMPLATE_PARM_INDEX);
1737 TEMPLATE_PARM_IDX (t) = index;
1738 TEMPLATE_PARM_LEVEL (t) = level;
1739 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
1740 TEMPLATE_PARM_DECL (t) = decl;
1741 TREE_TYPE (t) = type;
1746 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1747 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1748 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1749 new one is created. */
1752 reduce_template_parm_level (index, type, levels)
1757 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
1758 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
1759 != TEMPLATE_PARM_LEVEL (index) - levels))
1762 = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index)),
1763 DECL_NAME (TEMPLATE_PARM_DECL (index)),
1766 = build_template_parm_index (TEMPLATE_PARM_IDX (index),
1767 TEMPLATE_PARM_LEVEL (index) - levels,
1768 TEMPLATE_PARM_ORIG_LEVEL (index),
1770 TEMPLATE_PARM_DESCENDANTS (index) = t;
1772 /* Template template parameters need this. */
1773 DECL_TEMPLATE_PARMS (decl)
1774 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
1777 return TEMPLATE_PARM_DESCENDANTS (index);
1780 /* Process information from new template parameter NEXT and append it to the
1781 LIST being built. */
1784 process_template_parm (list, next)
1793 my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259);
1794 defval = TREE_PURPOSE (parm);
1795 parm = TREE_VALUE (parm);
1796 is_type = TREE_PURPOSE (parm) == class_type_node;
1800 tree p = TREE_VALUE (tree_last (list));
1802 if (TREE_CODE (p) == TYPE_DECL)
1803 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
1804 else if (TREE_CODE (p) == TEMPLATE_DECL)
1805 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (DECL_TEMPLATE_RESULT (p)));
1807 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
1815 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260);
1816 /* is a const-param */
1817 parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm),
1818 PARM, 0, NULL_TREE);
1822 The top-level cv-qualifiers on the template-parameter are
1823 ignored when determining its type. */
1824 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
1826 /* A template parameter is not modifiable. */
1827 TREE_READONLY (parm) = 1;
1828 if (IS_AGGR_TYPE (TREE_TYPE (parm))
1829 && TREE_CODE (TREE_TYPE (parm)) != TEMPLATE_TYPE_PARM
1830 && TREE_CODE (TREE_TYPE (parm)) != TYPENAME_TYPE)
1832 cp_error ("`%#T' is not a valid type for a template constant parameter",
1834 if (DECL_NAME (parm) == NULL_TREE)
1835 error (" a template type parameter must begin with `class' or `typename'");
1836 TREE_TYPE (parm) = void_type_node;
1839 && (TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE
1840 || TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE))
1841 cp_pedwarn ("`%T' is not a valid type for a template constant parameter",
1843 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
1844 DECL_INITIAL (parm) = DECL_INITIAL (decl)
1845 = build_template_parm_index (idx, processing_template_decl,
1846 processing_template_decl,
1847 decl, TREE_TYPE (parm));
1852 parm = TREE_VALUE (parm);
1854 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
1856 t = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1857 /* This is for distinguishing between real templates and template
1858 template parameters */
1859 TREE_TYPE (parm) = t;
1860 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
1865 t = make_lang_type (TEMPLATE_TYPE_PARM);
1866 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1867 decl = build_decl (TYPE_DECL, parm, t);
1870 TYPE_NAME (t) = decl;
1871 TYPE_STUB_DECL (t) = decl;
1873 TEMPLATE_TYPE_PARM_INDEX (t)
1874 = build_template_parm_index (idx, processing_template_decl,
1875 processing_template_decl,
1876 decl, TREE_TYPE (parm));
1878 SET_DECL_ARTIFICIAL (decl);
1879 DECL_TEMPLATE_PARM_P (decl) = 1;
1881 parm = build_tree_list (defval, parm);
1882 return chainon (list, parm);
1885 /* The end of a template parameter list has been reached. Process the
1886 tree list into a parameter vector, converting each parameter into a more
1887 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1891 end_template_parm_list (parms)
1896 tree saved_parmlist = make_tree_vec (list_length (parms));
1898 current_template_parms
1899 = tree_cons (build_int_2 (0, processing_template_decl),
1900 saved_parmlist, current_template_parms);
1902 for (parm = parms, nparms = 0;
1904 parm = TREE_CHAIN (parm), nparms++)
1905 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
1907 --processing_template_parmlist;
1909 return saved_parmlist;
1912 /* end_template_decl is called after a template declaration is seen. */
1915 end_template_decl ()
1917 reset_specialization ();
1919 if (! processing_template_decl)
1922 /* This matches the pushlevel in begin_template_parm_list. */
1925 --processing_template_decl;
1926 current_template_parms = TREE_CHAIN (current_template_parms);
1927 (void) get_pending_sizes (); /* Why? */
1930 /* Given a template argument vector containing the template PARMS.
1931 The innermost PARMS are given first. */
1934 current_template_args ()
1937 tree args = NULL_TREE;
1938 int length = TMPL_PARMS_DEPTH (current_template_parms);
1941 /* If there is only one level of template parameters, we do not
1942 create a TREE_VEC of TREE_VECs. Instead, we return a single
1943 TREE_VEC containing the arguments. */
1945 args = make_tree_vec (length);
1947 for (header = current_template_parms; header; header = TREE_CHAIN (header))
1949 tree a = copy_node (TREE_VALUE (header));
1952 TREE_TYPE (a) = NULL_TREE;
1953 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
1955 tree t = TREE_VEC_ELT (a, i);
1957 /* T will be a list if we are called from within a
1958 begin/end_template_parm_list pair, but a vector directly
1959 if within a begin/end_member_template_processing pair. */
1960 if (TREE_CODE (t) == TREE_LIST)
1964 if (TREE_CODE (t) == TYPE_DECL
1965 || TREE_CODE (t) == TEMPLATE_DECL)
1968 t = DECL_INITIAL (t);
1969 TREE_VEC_ELT (a, i) = t;
1974 TREE_VEC_ELT (args, --l) = a;
1982 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
1983 template PARMS. Used by push_template_decl below. */
1986 build_template_decl (decl, parms)
1990 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
1991 DECL_TEMPLATE_PARMS (tmpl) = parms;
1992 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
1993 if (DECL_LANG_SPECIFIC (decl))
1995 DECL_CLASS_CONTEXT (tmpl) = DECL_CLASS_CONTEXT (decl);
1996 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
1997 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
1998 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2004 struct template_parm_data
2006 /* The level of the template parameters we are currently
2010 /* The index of the specialization argument we are currently
2014 /* An array whose size is the number of template parameters. The
2015 elements are non-zero if the parameter has been used in any one
2016 of the arguments processed so far. */
2019 /* An array whose size is the number of template arguments. The
2020 elements are non-zero if the argument makes use of template
2021 parameters of this level. */
2022 int* arg_uses_template_parms;
2025 /* Subroutine of push_template_decl used to see if each template
2026 parameter in a partial specialization is used in the explicit
2027 argument list. If T is of the LEVEL given in DATA (which is
2028 treated as a template_parm_data*), then DATA->PARMS is marked
2032 mark_template_parm (t, data)
2038 struct template_parm_data* tpd = (struct template_parm_data*) data;
2040 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2042 level = TEMPLATE_PARM_LEVEL (t);
2043 idx = TEMPLATE_PARM_IDX (t);
2047 level = TEMPLATE_TYPE_LEVEL (t);
2048 idx = TEMPLATE_TYPE_IDX (t);
2051 if (level == tpd->level)
2053 tpd->parms[idx] = 1;
2054 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2057 /* Return zero so that for_each_template_parm will continue the
2058 traversal of the tree; we want to mark *every* template parm. */
2062 /* Process the partial specialization DECL. */
2065 process_partial_specialization (decl)
2068 tree type = TREE_TYPE (decl);
2069 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2070 tree specargs = CLASSTYPE_TI_ARGS (type);
2071 tree inner_args = innermost_args (specargs);
2072 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2073 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2074 int nargs = TREE_VEC_LENGTH (inner_args);
2075 int ntparms = TREE_VEC_LENGTH (inner_parms);
2077 int did_error_intro = 0;
2078 struct template_parm_data tpd;
2079 struct template_parm_data tpd2;
2081 /* We check that each of the template parameters given in the
2082 partial specialization is used in the argument list to the
2083 specialization. For example:
2085 template <class T> struct S;
2086 template <class T> struct S<T*>;
2088 The second declaration is OK because `T*' uses the template
2089 parameter T, whereas
2091 template <class T> struct S<int>;
2093 is no good. Even trickier is:
2104 The S2<T> declaration is actually illegal; it is a
2105 full-specialization. Of course,
2108 struct S2<T (*)(U)>;
2110 or some such would have been OK. */
2111 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2112 tpd.parms = alloca (sizeof (int) * ntparms);
2113 bzero ((PTR) tpd.parms, sizeof (int) * ntparms);
2115 tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
2116 bzero ((PTR) tpd.arg_uses_template_parms, sizeof (int) * nargs);
2117 for (i = 0; i < nargs; ++i)
2119 tpd.current_arg = i;
2120 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2121 &mark_template_parm,
2124 for (i = 0; i < ntparms; ++i)
2125 if (tpd.parms[i] == 0)
2127 /* One of the template parms was not used in the
2129 if (!did_error_intro)
2131 cp_error ("template parameters not used in partial specialization:");
2132 did_error_intro = 1;
2136 TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2139 /* [temp.class.spec]
2141 The argument list of the specialization shall not be identical to
2142 the implicit argument list of the primary template. */
2143 if (comp_template_args (inner_args,
2144 innermost_args (CLASSTYPE_TI_ARGS (TREE_TYPE
2146 cp_error ("partial specialization `%T' does not specialize any template arguments", type);
2148 /* [temp.class.spec]
2150 A partially specialized non-type argument expression shall not
2151 involve template parameters of the partial specialization except
2152 when the argument expression is a simple identifier.
2154 The type of a template parameter corresponding to a specialized
2155 non-type argument shall not be dependent on a parameter of the
2157 my_friendly_assert (nargs == DECL_NTPARMS (maintmpl), 0);
2159 for (i = 0; i < nargs; ++i)
2161 tree arg = TREE_VEC_ELT (inner_args, i);
2162 if (/* These first two lines are the `non-type' bit. */
2163 TREE_CODE_CLASS (TREE_CODE (arg)) != 't'
2164 && TREE_CODE (arg) != TEMPLATE_DECL
2165 /* This next line is the `argument expression is not just a
2166 simple identifier' condition and also the `specialized
2167 non-type argument' bit. */
2168 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2170 if (tpd.arg_uses_template_parms[i])
2171 cp_error ("template argument `%E' involves template parameter(s)", arg);
2174 /* Look at the corresponding template parameter,
2175 marking which template parameters its type depends
2178 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2183 /* We haven't yet initialized TPD2. Do so now. */
2184 tpd2.arg_uses_template_parms
2185 = (int*) alloca (sizeof (int) * nargs);
2186 /* The number of parameters here is the number in the
2187 main template, which, as checked in the assertion
2189 tpd2.parms = (int*) alloca (sizeof (int) * nargs);
2191 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2194 /* Mark the template parameters. But this time, we're
2195 looking for the template parameters of the main
2196 template, not in the specialization. */
2197 tpd2.current_arg = i;
2198 tpd2.arg_uses_template_parms[i] = 0;
2199 bzero ((PTR) tpd2.parms, sizeof (int) * nargs);
2200 for_each_template_parm (type,
2201 &mark_template_parm,
2204 if (tpd2.arg_uses_template_parms [i])
2206 /* The type depended on some template parameters.
2207 If they are fully specialized in the
2208 specialization, that's OK. */
2210 for (j = 0; j < nargs; ++j)
2211 if (tpd2.parms[j] != 0
2212 && tpd.arg_uses_template_parms [j])
2214 cp_error ("type `%T' of template argument `%E' depends on template parameter(s)",
2224 if (retrieve_specialization (maintmpl, specargs))
2225 /* We've already got this specialization. */
2228 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl) = CLASSTYPE_TI_SPEC_INFO (type)
2229 = tree_cons (inner_args, inner_parms,
2230 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2231 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2235 /* Check that a template declaration's use of default arguments is not
2236 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2237 non-zero if DECL is the thing declared by a primary template.
2238 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2241 check_default_tmpl_args (decl, parms, is_primary, is_partial)
2248 int last_level_to_check;
2253 A default template-argument shall not be specified in a
2254 function template declaration or a function template definition, nor
2255 in the template-parameter-list of the definition of a member of a
2258 if (TREE_CODE (DECL_REAL_CONTEXT (decl)) == FUNCTION_DECL)
2259 /* You can't have a function template declaration in a local
2260 scope, nor you can you define a member of a class template in a
2264 if (current_class_type
2265 && !TYPE_BEING_DEFINED (current_class_type)
2266 && DECL_LANG_SPECIFIC (decl)
2267 /* If this is either a friend defined in the scope of the class
2268 or a member function. */
2269 && DECL_CLASS_CONTEXT (decl) == current_class_type
2270 /* And, if it was a member function, it really was defined in
2271 the scope of the class. */
2272 && (!DECL_FUNCTION_MEMBER_P (decl) || DECL_DEFINED_IN_CLASS_P (decl)))
2273 /* We already checked these parameters when the template was
2274 declared, so there's no need to do it again now. This function
2275 was defined in class scope, but we're processing it's body now
2276 that the class is complete. */
2281 If a template-parameter has a default template-argument, all
2282 subsequent template-parameters shall have a default
2283 template-argument supplied. */
2284 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2286 tree inner_parms = TREE_VALUE (parm_level);
2287 int ntparms = TREE_VEC_LENGTH (inner_parms);
2288 int seen_def_arg_p = 0;
2291 for (i = 0; i < ntparms; ++i)
2293 tree parm = TREE_VEC_ELT (inner_parms, i);
2294 if (TREE_PURPOSE (parm))
2296 else if (seen_def_arg_p)
2298 cp_error ("no default argument for `%D'", TREE_VALUE (parm));
2299 /* For better subsequent error-recovery, we indicate that
2300 there should have been a default argument. */
2301 TREE_PURPOSE (parm) = error_mark_node;
2306 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2307 /* For an ordinary class template, default template arguments are
2308 allowed at the innermost level, e.g.:
2309 template <class T = int>
2311 but, in a partial specialization, they're not allowed even
2312 there, as we have in [temp.class.spec]:
2314 The template parameter list of a specialization shall not
2315 contain default template argument values.
2317 So, for a partial specialization, or for a function template,
2318 we look at all of them. */
2321 /* But, for a primary class template that is not a partial
2322 specialization we look at all template parameters except the
2324 parms = TREE_CHAIN (parms);
2326 /* Figure out what error message to issue. */
2327 if (TREE_CODE (decl) == FUNCTION_DECL)
2328 msg = "default argument for template parameter in function template `%D'";
2329 else if (is_partial)
2330 msg = "default argument in partial specialization `%D'";
2332 msg = "default argument for template parameter for class enclosing `%D'";
2334 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2335 /* If we're inside a class definition, there's no need to
2336 examine the parameters to the class itself. On the one
2337 hand, they will be checked when the class is defined, and,
2338 on the other, default arguments are legal in things like:
2339 template <class T = double>
2340 struct S { template <class U> void f(U); };
2341 Here the default argument for `S' has no bearing on the
2342 declaration of `f'. */
2343 last_level_to_check = template_class_depth (current_class_type) + 1;
2345 /* Check everything. */
2346 last_level_to_check = 0;
2348 for (parm_level = parms;
2349 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2350 parm_level = TREE_CHAIN (parm_level))
2352 tree inner_parms = TREE_VALUE (parm_level);
2356 ntparms = TREE_VEC_LENGTH (inner_parms);
2357 for (i = 0; i < ntparms; ++i)
2358 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2362 cp_error (msg, decl);
2366 /* Clear out the default argument so that we are not
2368 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2371 /* At this point, if we're still interested in issuing messages,
2372 they must apply to classes surrounding the object declared. */
2374 msg = "default argument for template parameter for class enclosing `%D'";
2378 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2379 parameters given by current_template_args, or reuses a
2380 previously existing one, if appropriate. Returns the DECL, or an
2381 equivalent one, if it is replaced via a call to duplicate_decls.
2383 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2386 push_template_decl_real (decl, is_friend)
2396 int new_template_p = 0;
2398 /* See if this is a partial specialization. */
2399 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
2400 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
2401 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
2403 is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl));
2406 /* For a friend, we want the context of the friend function, not
2407 the type of which it is a friend. */
2408 ctx = DECL_CONTEXT (decl);
2409 else if (DECL_REAL_CONTEXT (decl)
2410 && TREE_CODE (DECL_REAL_CONTEXT (decl)) != NAMESPACE_DECL)
2411 /* In the case of a virtual function, we want the class in which
2413 ctx = DECL_REAL_CONTEXT (decl);
2415 /* Otherwise, if we're currently definining some class, the DECL
2416 is assumed to be a member of the class. */
2417 ctx = current_scope ();
2419 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
2422 if (!DECL_CONTEXT (decl))
2423 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2425 /* See if this is a primary template. */
2426 primary = pseudo_global_level_p ();
2430 if (current_lang_name == lang_name_c)
2431 cp_error ("template with C linkage");
2432 else if (TREE_CODE (decl) == TYPE_DECL
2433 && ANON_AGGRNAME_P (DECL_NAME (decl)))
2434 cp_error ("template class without a name");
2435 else if ((DECL_IMPLICIT_TYPEDEF_P (decl)
2436 && CLASS_TYPE_P (TREE_TYPE (decl)))
2437 || (TREE_CODE (decl) == VAR_DECL && ctx && CLASS_TYPE_P (ctx))
2438 || TREE_CODE (decl) == FUNCTION_DECL)
2441 cp_error ("template declaration of `%#D'", decl);
2444 /* Check to see that the rules regarding the use of default
2445 arguments are not being violated. */
2446 check_default_tmpl_args (decl, current_template_parms,
2447 primary, is_partial);
2450 return process_partial_specialization (decl);
2452 args = current_template_args ();
2455 || TREE_CODE (ctx) == FUNCTION_DECL
2456 || TYPE_BEING_DEFINED (ctx)
2457 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
2459 if (DECL_LANG_SPECIFIC (decl)
2460 && DECL_TEMPLATE_INFO (decl)
2461 && DECL_TI_TEMPLATE (decl))
2462 tmpl = DECL_TI_TEMPLATE (decl);
2463 /* If DECL is a TYPE_DECL for a class-template, then there won't
2464 be DECL_LANG_SPECIFIC. The information equivalent to
2465 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2466 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
2467 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2468 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2470 /* Since a template declaration already existed for this
2471 class-type, we must be redeclaring it here. Make sure
2472 that the redeclaration is legal. */
2473 redeclare_class_template (TREE_TYPE (decl),
2474 current_template_parms);
2475 /* We don't need to create a new TEMPLATE_DECL; just use the
2476 one we already had. */
2477 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
2481 tmpl = build_template_decl (decl, current_template_parms);
2484 if (DECL_LANG_SPECIFIC (decl)
2485 && DECL_TEMPLATE_SPECIALIZATION (decl))
2487 /* A specialization of a member template of a template
2489 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2490 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
2491 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
2497 tree a, t, current, parms;
2500 if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx))
2501 cp_error ("must specialize `%#T' before defining member `%#D'",
2503 if (TREE_CODE (decl) == TYPE_DECL)
2505 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
2506 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2507 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2508 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2509 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
2512 cp_error ("`%D' does not declare a template type", decl);
2516 else if (! DECL_TEMPLATE_INFO (decl))
2518 cp_error ("template definition of non-template `%#D'", decl);
2522 tmpl = DECL_TI_TEMPLATE (decl);
2524 if (is_member_template (tmpl)
2525 && DECL_FUNCTION_TEMPLATE_P (tmpl)
2526 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
2527 && DECL_TEMPLATE_SPECIALIZATION (decl))
2531 /* The declaration is a specialization of a member
2532 template, declared outside the class. Therefore, the
2533 innermost template arguments will be NULL, so we
2534 replace them with the arguments determined by the
2535 earlier call to check_explicit_specialization. */
2536 args = DECL_TI_ARGS (decl);
2539 = build_template_decl (decl, current_template_parms);
2540 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
2541 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
2542 DECL_TI_TEMPLATE (decl) = new_tmpl;
2543 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
2544 DECL_TEMPLATE_INFO (new_tmpl)
2545 = tree_cons (tmpl, args, NULL_TREE);
2547 register_specialization (new_tmpl, tmpl, args);
2551 /* Make sure the template headers we got make sense. */
2553 parms = DECL_TEMPLATE_PARMS (tmpl);
2554 i = TMPL_PARMS_DEPTH (parms);
2555 if (TMPL_ARGS_DEPTH (args) != i)
2557 cp_error ("expected %d levels of template parms for `%#D', got %d",
2558 i, decl, TMPL_ARGS_DEPTH (args));
2561 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
2563 a = TMPL_ARGS_LEVEL (args, i);
2564 t = INNERMOST_TEMPLATE_PARMS (parms);
2566 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
2568 if (current == decl)
2569 cp_error ("got %d template parameters for `%#D'",
2570 TREE_VEC_LENGTH (a), decl);
2572 cp_error ("got %d template parameters for `%#T'",
2573 TREE_VEC_LENGTH (a), current);
2574 cp_error (" but %d required", TREE_VEC_LENGTH (t));
2577 /* Perhaps we should also check that the parms are used in the
2578 appropriate qualifying scopes in the declarator? */
2580 if (current == decl)
2583 current = TYPE_CONTEXT (current);
2587 DECL_TEMPLATE_RESULT (tmpl) = decl;
2588 TREE_TYPE (tmpl) = TREE_TYPE (decl);
2590 /* Push template declarations for global functions and types. Note
2591 that we do not try to push a global template friend declared in a
2592 template class; such a thing may well depend on the template
2593 parameters of the class. */
2594 if (new_template_p && !ctx
2595 && !(is_friend && template_class_depth (current_class_type) > 0))
2596 tmpl = pushdecl_namespace_level (tmpl);
2599 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
2601 info = tree_cons (tmpl, args, NULL_TREE);
2603 if (DECL_IMPLICIT_TYPEDEF_P (decl))
2605 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
2606 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
2607 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE)
2608 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
2610 else if (DECL_LANG_SPECIFIC (decl))
2611 DECL_TEMPLATE_INFO (decl) = info;
2613 return DECL_TEMPLATE_RESULT (tmpl);
2617 push_template_decl (decl)
2620 return push_template_decl_real (decl, 0);
2623 /* Called when a class template TYPE is redeclared with the indicated
2624 template PARMS, e.g.:
2626 template <class T> struct S;
2627 template <class T> struct S {}; */
2630 redeclare_class_template (type, parms)
2638 if (!TYPE_TEMPLATE_INFO (type))
2640 cp_error ("`%T' is not a template type", type);
2644 tmpl = TYPE_TI_TEMPLATE (type);
2645 if (!PRIMARY_TEMPLATE_P (tmpl))
2646 /* The type is nested in some template class. Nothing to worry
2647 about here; there are no new template parameters for the nested
2651 parms = INNERMOST_TEMPLATE_PARMS (parms);
2652 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
2654 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
2656 cp_error_at ("previous declaration `%D'", tmpl);
2657 cp_error ("used %d template parameter%s instead of %d",
2658 TREE_VEC_LENGTH (tmpl_parms),
2659 TREE_VEC_LENGTH (tmpl_parms) == 1 ? "" : "s",
2660 TREE_VEC_LENGTH (parms));
2664 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
2666 tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
2667 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
2668 tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
2669 tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
2671 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm))
2673 cp_error_at ("template parameter `%#D'", tmpl_parm);
2674 cp_error ("redeclared here as `%#D'", parm);
2678 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
2680 /* We have in [temp.param]:
2682 A template-parameter may not be given default arguments
2683 by two different declarations in the same scope. */
2684 cp_error ("redefinition of default argument for `%#D'", parm);
2685 cp_error_at (" original definition appeared here", tmpl_parm);
2689 if (parm_default != NULL_TREE)
2690 /* Update the previous template parameters (which are the ones
2691 that will really count) with the new default value. */
2692 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
2693 else if (tmpl_default != NULL_TREE)
2694 /* Update the new parameters, too; they'll be used as the
2695 parameters for any members. */
2696 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
2700 /* Attempt to convert the non-type template parameter EXPR to the
2701 indicated TYPE. If the conversion is successful, return the
2702 converted value. If the conversion is unsuccesful, return
2703 NULL_TREE if we issued an error message, or error_mark_node if we
2704 did not. We issue error messages for out-and-out bad template
2705 parameters, but not simply because the conversion failed, since we
2706 might be just trying to do argument deduction. By the time this
2707 function is called, neither TYPE nor EXPR may make use of template
2711 convert_nontype_argument (type, expr)
2715 tree expr_type = TREE_TYPE (expr);
2717 /* A template-argument for a non-type, non-template
2718 template-parameter shall be one of:
2720 --an integral constant-expression of integral or enumeration
2723 --the name of a non-type template-parameter; or
2725 --the name of an object or function with external linkage,
2726 including function templates and function template-ids but
2727 excluding non-static class members, expressed as id-expression;
2730 --the address of an object or function with external linkage,
2731 including function templates and function template-ids but
2732 excluding non-static class members, expressed as & id-expression
2733 where the & is optional if the name refers to a function or
2736 --a pointer to member expressed as described in _expr.unary.op_. */
2738 /* An integral constant-expression can include const variables or
2739 enumerators. Simplify things by folding them to their values,
2740 unless we're about to bind the declaration to a reference
2742 if (INTEGRAL_TYPE_P (expr_type) && TREE_READONLY_DECL_P (expr)
2743 && TREE_CODE (type) != REFERENCE_TYPE)
2744 expr = decl_constant_value (expr);
2746 if (is_overloaded_fn (expr))
2747 /* OK for now. We'll check that it has external linkage later.
2748 Check this first since if expr_type is the unknown_type_node
2749 we would otherwise complain below. */
2751 else if (TYPE_PTRMEM_P (expr_type)
2752 || TYPE_PTRMEMFUNC_P (expr_type))
2754 if (TREE_CODE (expr) != PTRMEM_CST)
2757 else if (TYPE_PTR_P (expr_type)
2758 || TYPE_PTRMEM_P (expr_type)
2759 || TREE_CODE (expr_type) == ARRAY_TYPE
2760 || TREE_CODE (type) == REFERENCE_TYPE
2761 /* If expr is the address of an overloaded function, we
2762 will get the unknown_type_node at this point. */
2763 || expr_type == unknown_type_node)
2769 if (TREE_CODE (type) == REFERENCE_TYPE
2770 || TREE_CODE (expr_type) == ARRAY_TYPE)
2774 if (TREE_CODE (e) != ADDR_EXPR)
2777 cp_error ("`%E' is not a valid template argument", expr);
2778 if (TYPE_PTR_P (expr_type))
2780 if (TREE_CODE (TREE_TYPE (expr_type)) == FUNCTION_TYPE)
2781 cp_error ("it must be the address of a function with external linkage");
2783 cp_error ("it must be the address of an object with external linkage");
2785 else if (TYPE_PTRMEM_P (expr_type)
2786 || TYPE_PTRMEMFUNC_P (expr_type))
2787 cp_error ("it must be a pointer-to-member of the form `&X::Y'");
2792 referent = TREE_OPERAND (e, 0);
2793 STRIP_NOPS (referent);
2796 if (TREE_CODE (referent) == STRING_CST)
2798 cp_error ("string literal %E is not a valid template argument",
2800 error ("because it is the address of an object with static linkage");
2804 if (is_overloaded_fn (referent))
2805 /* We'll check that it has external linkage later. */
2807 else if (TREE_CODE (referent) != VAR_DECL)
2809 else if (!TREE_PUBLIC (referent))
2811 cp_error ("address of non-extern `%E' cannot be used as template argument", referent);
2812 return error_mark_node;
2815 else if (INTEGRAL_TYPE_P (expr_type)
2816 || TYPE_PTRMEM_P (expr_type)
2817 || TYPE_PTRMEMFUNC_P (expr_type)
2818 /* The next two are g++ extensions. */
2819 || TREE_CODE (expr_type) == REAL_TYPE
2820 || TREE_CODE (expr_type) == COMPLEX_TYPE)
2822 if (! TREE_CONSTANT (expr))
2825 cp_error ("non-constant `%E' cannot be used as template argument",
2832 cp_error ("object `%E' cannot be used as template argument", expr);
2836 switch (TREE_CODE (type))
2841 /* For a non-type template-parameter of integral or enumeration
2842 type, integral promotions (_conv.prom_) and integral
2843 conversions (_conv.integral_) are applied. */
2844 if (!INTEGRAL_TYPE_P (expr_type))
2845 return error_mark_node;
2847 /* It's safe to call digest_init in this case; we know we're
2848 just converting one integral constant expression to another. */
2849 expr = digest_init (type, expr, (tree*) 0);
2851 if (TREE_CODE (expr) != INTEGER_CST)
2852 /* Curiously, some TREE_CONSTANT integral expressions do not
2853 simplify to integer constants. For example, `3 % 0',
2854 remains a TRUNC_MOD_EXPR. */
2861 /* These are g++ extensions. */
2862 if (TREE_CODE (expr_type) != TREE_CODE (type))
2863 return error_mark_node;
2865 expr = digest_init (type, expr, (tree*) 0);
2867 if (TREE_CODE (expr) != REAL_CST)
2874 tree type_pointed_to = TREE_TYPE (type);
2876 if (TYPE_PTRMEM_P (type))
2880 /* For a non-type template-parameter of type pointer to data
2881 member, qualification conversions (_conv.qual_) are
2883 e = perform_qualification_conversions (type, expr);
2884 if (TREE_CODE (e) == NOP_EXPR)
2885 /* The call to perform_qualification_conversions will
2886 insert a NOP_EXPR over EXPR to do express conversion,
2887 if necessary. But, that will confuse us if we use
2888 this (converted) template parameter to instantiate
2889 another template; then the thing will not look like a
2890 valid template argument. So, just make a new
2891 constant, of the appropriate type. */
2892 e = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr));
2895 else if (TREE_CODE (type_pointed_to) == FUNCTION_TYPE)
2897 /* For a non-type template-parameter of type pointer to
2898 function, only the function-to-pointer conversion
2899 (_conv.func_) is applied. If the template-argument
2900 represents a set of overloaded functions (or a pointer to
2901 such), the matching function is selected from the set
2906 if (TREE_CODE (expr) == ADDR_EXPR)
2907 fns = TREE_OPERAND (expr, 0);
2911 fn = instantiate_type (type_pointed_to, fns, 0);
2913 if (fn == error_mark_node)
2914 return error_mark_node;
2916 if (!TREE_PUBLIC (fn))
2918 if (really_overloaded_fn (fns))
2919 return error_mark_node;
2924 expr = build_unary_op (ADDR_EXPR, fn, 0);
2926 my_friendly_assert (same_type_p (type, TREE_TYPE (expr)),
2932 /* For a non-type template-parameter of type pointer to
2933 object, qualification conversions (_conv.qual_) and the
2934 array-to-pointer conversion (_conv.array_) are applied.
2935 [Note: In particular, neither the null pointer conversion
2936 (_conv.ptr_) nor the derived-to-base conversion
2937 (_conv.ptr_) are applied. Although 0 is a valid
2938 template-argument for a non-type template-parameter of
2939 integral type, it is not a valid template-argument for a
2940 non-type template-parameter of pointer type.]
2942 The call to decay_conversion performs the
2943 array-to-pointer conversion, if appropriate. */
2944 expr = decay_conversion (expr);
2946 if (expr == error_mark_node)
2947 return error_mark_node;
2949 return perform_qualification_conversions (type, expr);
2954 case REFERENCE_TYPE:
2956 tree type_referred_to = TREE_TYPE (type);
2958 if (TREE_CODE (type_referred_to) == FUNCTION_TYPE)
2960 /* For a non-type template-parameter of type reference to
2961 function, no conversions apply. If the
2962 template-argument represents a set of overloaded
2963 functions, the matching function is selected from the
2964 set (_over.over_). */
2968 fn = instantiate_type (type_referred_to, fns, 0);
2970 if (fn == error_mark_node)
2971 return error_mark_node;
2973 if (!TREE_PUBLIC (fn))
2975 if (really_overloaded_fn (fns))
2976 /* Don't issue an error here; we might get a different
2977 function if the overloading had worked out
2979 return error_mark_node;
2984 my_friendly_assert (same_type_p (type_referred_to,
2992 /* For a non-type template-parameter of type reference to
2993 object, no conversions apply. The type referred to by the
2994 reference may be more cv-qualified than the (otherwise
2995 identical) type of the template-argument. The
2996 template-parameter is bound directly to the
2997 template-argument, which must be an lvalue. */
2998 if ((TYPE_MAIN_VARIANT (expr_type)
2999 != TYPE_MAIN_VARIANT (type_referred_to))
3000 || !at_least_as_qualified_p (type_referred_to,
3002 || !real_lvalue_p (expr))
3003 return error_mark_node;
3012 if (!TYPE_PTRMEMFUNC_P (type))
3013 /* This handles templates like
3014 template<class T, T t> void f();
3015 when T is substituted with any class. The second template
3016 parameter becomes invalid and the template candidate is
3018 return error_mark_node;
3020 /* For a non-type template-parameter of type pointer to member
3021 function, no conversions apply. If the template-argument
3022 represents a set of overloaded member functions, the
3023 matching member function is selected from the set
3026 if (!TYPE_PTRMEMFUNC_P (expr_type) &&
3027 expr_type != unknown_type_node)
3028 return error_mark_node;
3030 if (TREE_CODE (expr) == PTRMEM_CST)
3032 /* A ptr-to-member constant. */
3033 if (!same_type_p (type, expr_type))
3034 return error_mark_node;
3039 if (TREE_CODE (expr) != ADDR_EXPR)
3040 return error_mark_node;
3042 expr = instantiate_type (type, expr, 0);
3044 if (expr == error_mark_node)
3045 return error_mark_node;
3047 my_friendly_assert (same_type_p (type, TREE_TYPE (expr)),
3054 /* All non-type parameters must have one of these types. */
3055 my_friendly_abort (0);
3059 return error_mark_node;
3062 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3063 template template parameters. Both PARM_PARMS and ARG_PARMS are
3064 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3067 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3068 the case, then extra parameters must have default arguments.
3070 Consider the example:
3071 template <class T, class Allocator = allocator> class vector;
3072 template<template <class U> class TT> class C;
3074 C<vector> is a valid instantiation. PARM_PARMS for the above code
3075 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3076 T and Allocator) and OUTER_ARGS contains the argument that is used to
3077 substitute the TT parameter. */
3080 coerce_template_template_parms (parm_parms, arg_parms, complain,
3081 in_decl, outer_args)
3082 tree parm_parms, arg_parms;
3084 tree in_decl, outer_args;
3086 int nparms, nargs, i;
3089 my_friendly_assert (TREE_CODE (parm_parms) == TREE_VEC, 0);
3090 my_friendly_assert (TREE_CODE (arg_parms) == TREE_VEC, 0);
3092 nparms = TREE_VEC_LENGTH (parm_parms);
3093 nargs = TREE_VEC_LENGTH (arg_parms);
3095 /* The rule here is opposite of coerce_template_parms. */
3098 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE))
3101 for (i = 0; i < nparms; ++i)
3103 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3104 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3106 if (arg == NULL_TREE || arg == error_mark_node
3107 || parm == NULL_TREE || parm == error_mark_node)
3110 if (TREE_CODE (arg) != TREE_CODE (parm))
3113 switch (TREE_CODE (parm))
3119 /* We encounter instantiations of templates like
3120 template <template <template <class> class> class TT>
3123 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3124 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3126 if (!coerce_template_template_parms (parmparm, argparm,
3134 /* The tsubst call is used to handle cases such as
3135 template <class T, template <T> class TT> class D;
3136 i.e. the parameter list of TT depends on earlier parameters. */
3137 if (!same_type_p (tsubst (TREE_TYPE (parm), outer_args,
3144 my_friendly_abort (0);
3150 /* Convert the indicated template ARG as necessary to match the
3151 indicated template PARM. Returns the converted ARG, or
3152 error_mark_node if the conversion was unsuccessful. Error messages
3153 are issued if COMPLAIN is non-zero. This conversion is for the Ith
3154 parameter in the parameter list. ARGS is the full set of template
3155 arguments deduced so far. */
3158 convert_template_argument (parm, arg, args, complain, i, in_decl)
3168 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3170 inner_args = innermost_args (args);
3172 if (TREE_CODE (arg) == TREE_LIST
3173 && TREE_TYPE (arg) != NULL_TREE
3174 && TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)
3176 /* The template argument was the name of some
3177 member function. That's usually
3178 illegal, but static members are OK. In any
3179 case, grab the underlying fields/functions
3180 and issue an error later if required. */
3181 arg = TREE_VALUE (arg);
3182 TREE_TYPE (arg) = unknown_type_node;
3185 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3186 requires_type = (TREE_CODE (parm) == TYPE_DECL
3187 || requires_tmpl_type);
3189 /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true,
3190 we also accept implicitly created TYPE_DECL as a valid argument.
3191 This is necessary to handle the case where we pass a template name
3192 to a template template parameter in a scope where we've derived from
3193 in instantiation of that template, so the template name refers to that
3194 instantiation. We really ought to handle this better. */
3196 = ((TREE_CODE (arg) == TEMPLATE_DECL
3197 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3198 || (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3199 && !TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (arg))
3200 || (TREE_CODE (arg) == RECORD_TYPE
3201 && CLASSTYPE_TEMPLATE_INFO (arg)
3202 && TREE_CODE (TYPE_NAME (arg)) == TYPE_DECL
3203 && DECL_ARTIFICIAL (TYPE_NAME (arg))
3204 && requires_tmpl_type
3205 && is_base_of_enclosing_class (arg, current_class_type)));
3206 if (is_tmpl_type && TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
3207 arg = TYPE_STUB_DECL (arg);
3208 else if (is_tmpl_type && TREE_CODE (arg) == RECORD_TYPE)
3209 arg = CLASSTYPE_TI_TEMPLATE (arg);
3211 is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't' || is_tmpl_type;
3213 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3214 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3216 cp_pedwarn ("to refer to a type member of a template parameter,");
3217 cp_pedwarn (" use `typename %E'", arg);
3219 arg = make_typename_type (TREE_OPERAND (arg, 0),
3220 TREE_OPERAND (arg, 1));
3223 if (is_type != requires_type)
3229 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3232 cp_error (" expected a constant of type `%T', got `%T'",
3234 (is_tmpl_type ? DECL_NAME (arg) : arg));
3236 cp_error (" expected a type, got `%E'", arg);
3239 return error_mark_node;
3241 if (is_tmpl_type ^ requires_tmpl_type)
3243 if (in_decl && complain)
3245 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3248 cp_error (" expected a type, got `%T'", DECL_NAME (arg));
3250 cp_error (" expected a class template, got `%T'", arg);
3252 return error_mark_node;
3257 if (requires_tmpl_type)
3259 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3260 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3262 if (coerce_template_template_parms (parmparm, argparm, complain,
3263 in_decl, inner_args))
3267 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3269 if (val != error_mark_node
3270 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
3271 val = TREE_TYPE (val);
3275 if (in_decl && complain)
3277 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3279 cp_error (" expected a template of type `%D', got `%D'", parm, arg);
3282 val = error_mark_node;
3287 val = groktypename (arg);
3288 if (! processing_template_decl)
3290 /* [basic.link]: A name with no linkage (notably, the
3291 name of a class or enumeration declared in a local
3292 scope) shall not be used to declare an entity with
3293 linkage. This implies that names with no linkage
3294 cannot be used as template arguments. */
3295 tree t = no_linkage_check (val);
3298 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
3300 ("template-argument `%T' uses anonymous type", val);
3303 ("template-argument `%T' uses local type `%T'",
3305 return error_mark_node;
3312 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
3314 if (processing_template_decl)
3315 arg = maybe_fold_nontype_arg (arg);
3317 if (!uses_template_parms (arg) && !uses_template_parms (t))
3318 /* We used to call digest_init here. However, digest_init
3319 will report errors, which we don't want when complain
3320 is zero. More importantly, digest_init will try too
3321 hard to convert things: for example, `0' should not be
3322 converted to pointer type at this point according to
3323 the standard. Accepting this is not merely an
3324 extension, since deciding whether or not these
3325 conversions can occur is part of determining which
3326 function template to call, or whether a given epxlicit
3327 argument specification is legal. */
3328 val = convert_nontype_argument (t, arg);
3332 if (val == NULL_TREE)
3333 val = error_mark_node;
3334 else if (val == error_mark_node && complain)
3335 cp_error ("could not convert template argument `%E' to `%T'",
3342 /* Convert all template arguments to their appropriate types, and
3343 return a vector containing the innermost resulting template
3344 arguments. If any error occurs, return error_mark_node, and, if
3345 COMPLAIN is non-zero, issue an error message. Some error messages
3346 are issued even if COMPLAIN is zero; for instance, if a template
3347 argument is composed from a local class.
3349 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3350 provided in ARGLIST, or else trailing parameters must have default
3351 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3352 deduction for any unspecified trailing arguments.
3354 The resulting TREE_VEC is allocated on a temporary obstack, and
3355 must be explicitly copied if it will be permanent. */
3358 coerce_template_parms (parms, args, in_decl,
3360 require_all_arguments)
3364 int require_all_arguments;
3366 int nparms, nargs, i, lost = 0;
3369 tree new_inner_args;
3371 inner_args = innermost_args (args);
3372 nargs = NUM_TMPL_ARGS (inner_args);
3373 nparms = TREE_VEC_LENGTH (parms);
3377 && require_all_arguments
3378 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
3382 cp_error ("wrong number of template arguments (%d, should be %d)",
3386 cp_error_at ("provided for `%D'", in_decl);
3389 return error_mark_node;
3392 new_inner_args = make_temp_vec (nparms);
3393 new_args = add_outermost_template_args (args, new_inner_args);
3394 for (i = 0; i < nparms; i++)
3399 /* Get the Ith template parameter. */
3400 parm = TREE_VEC_ELT (parms, i);
3402 /* Calculate the Ith argument. */
3403 if (inner_args && TREE_CODE (inner_args) == TREE_LIST)
3405 arg = TREE_VALUE (inner_args);
3406 inner_args = TREE_CHAIN (inner_args);
3409 arg = TREE_VEC_ELT (inner_args, i);
3410 /* If no template argument was supplied, look for a default
3412 else if (TREE_PURPOSE (parm) == NULL_TREE)
3414 /* There was no default value. */
3415 my_friendly_assert (!require_all_arguments, 0);
3418 else if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL)
3419 arg = tsubst (TREE_PURPOSE (parm), new_args, complain, in_decl);
3421 arg = tsubst_expr (TREE_PURPOSE (parm), new_args, complain,
3424 /* Now, convert the Ith argument, as necessary. */
3425 if (arg == NULL_TREE)
3426 /* We're out of arguments. */
3428 my_friendly_assert (!require_all_arguments, 0);
3431 else if (arg == error_mark_node)
3433 cp_error ("template argument %d is invalid", i + 1);
3434 arg = error_mark_node;
3437 arg = convert_template_argument (TREE_VALUE (parm),
3438 arg, new_args, complain, i,
3441 if (arg == error_mark_node)
3443 TREE_VEC_ELT (new_inner_args, i) = arg;
3447 return error_mark_node;
3449 return new_inner_args;
3452 /* Returns 1 if template args OT and NT are equivalent. */
3455 template_args_equal (ot, nt)
3460 if (TREE_CODE (nt) != TREE_CODE (ot))
3462 if (TREE_CODE (nt) == TREE_VEC)
3463 /* For member templates */
3464 return comp_template_args (ot, nt);
3465 else if (TREE_CODE_CLASS (TREE_CODE (ot)) == 't')
3466 return same_type_p (ot, nt);
3468 return (cp_tree_equal (ot, nt) > 0);
3471 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3472 of template arguments. Returns 0 otherwise. */
3475 comp_template_args (oldargs, newargs)
3476 tree oldargs, newargs;
3480 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
3483 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
3485 tree nt = TREE_VEC_ELT (newargs, i);
3486 tree ot = TREE_VEC_ELT (oldargs, i);
3488 if (! template_args_equal (ot, nt))
3494 /* Given class template name and parameter list, produce a user-friendly name
3495 for the instantiation. */
3498 mangle_class_name_for_template (name, parms, arglist)
3500 tree parms, arglist;
3502 static struct obstack scratch_obstack;
3503 static char *scratch_firstobj;
3506 if (!scratch_firstobj)
3507 gcc_obstack_init (&scratch_obstack);
3509 obstack_free (&scratch_obstack, scratch_firstobj);
3510 scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
3512 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
3513 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
3517 nparms = TREE_VEC_LENGTH (parms);
3518 arglist = innermost_args (arglist);
3519 my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268);
3520 for (i = 0; i < nparms; i++)
3522 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3523 tree arg = TREE_VEC_ELT (arglist, i);
3528 if (TREE_CODE (parm) == TYPE_DECL)
3530 cat (type_as_string_real (arg, 0, 1));
3533 else if (TREE_CODE (parm) == TEMPLATE_DECL)
3535 if (TREE_CODE (arg) == TEMPLATE_DECL)
3537 /* Already substituted with real template. Just output
3538 the template name here */
3539 tree context = DECL_CONTEXT (arg);
3542 /* The template may be defined in a namespace, or
3543 may be a member template. */
3544 my_friendly_assert (TREE_CODE (context) == NAMESPACE_DECL
3545 || CLASS_TYPE_P (context),
3547 cat(decl_as_string (DECL_CONTEXT (arg), 0));
3550 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
3553 /* Output the parameter declaration */
3554 cat (type_as_string_real (arg, 0, 1));
3558 my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269);
3560 if (TREE_CODE (arg) == TREE_LIST)
3562 /* New list cell was built because old chain link was in
3564 my_friendly_assert (TREE_PURPOSE (arg) == NULL_TREE, 270);
3565 arg = TREE_VALUE (arg);
3567 /* No need to check arglist against parmlist here; we did that
3568 in coerce_template_parms, called from lookup_template_class. */
3569 cat (expr_as_string (arg, 0));
3572 char *bufp = obstack_next_free (&scratch_obstack);
3574 while (bufp[offset - 1] == ' ')
3576 obstack_blank_fast (&scratch_obstack, offset);
3578 /* B<C<char> >, not B<C<char>> */
3579 if (bufp[offset - 1] == '>')
3584 return (char *) obstack_base (&scratch_obstack);
3588 classtype_mangled_name (t)
3591 if (CLASSTYPE_TEMPLATE_INFO (t)
3592 /* Specializations have already had their names set up in
3593 lookup_template_class. */
3594 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
3596 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
3598 /* For non-primary templates, the template parameters are
3599 implicit from their surrounding context. */
3600 if (PRIMARY_TEMPLATE_P (tmpl))
3602 tree name = DECL_NAME (tmpl);
3603 char *mangled_name = mangle_class_name_for_template
3604 (IDENTIFIER_POINTER (name),
3605 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
3606 CLASSTYPE_TI_ARGS (t));
3607 tree id = get_identifier (mangled_name);
3608 IDENTIFIER_TEMPLATE (id) = name;
3613 return TYPE_IDENTIFIER (t);
3617 add_pending_template (d)
3622 if (TREE_CODE_CLASS (TREE_CODE (d)) == 't')
3623 ti = CLASSTYPE_TEMPLATE_INFO (d);
3625 ti = DECL_TEMPLATE_INFO (d);
3627 if (TI_PENDING_TEMPLATE_FLAG (ti))
3630 *template_tail = tree_cons (build_srcloc_here (), d, NULL_TREE);
3631 template_tail = &TREE_CHAIN (*template_tail);
3632 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
3636 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3637 may be either a _DECL or an overloaded function or an
3638 IDENTIFIER_NODE), and ARGLIST. */
3641 lookup_template_function (fns, arglist)
3646 if (fns == NULL_TREE)
3648 cp_error ("non-template used as template");
3649 return error_mark_node;
3652 type = TREE_TYPE (fns);
3653 if (TREE_CODE (fns) == OVERLOAD || !type)
3654 type = unknown_type_node;
3656 if (processing_template_decl)
3657 return build_min (TEMPLATE_ID_EXPR, type, fns, arglist);
3659 return build (TEMPLATE_ID_EXPR, type, fns, arglist);
3662 /* Within the scope of a template class S<T>, the name S gets bound
3663 (in build_self_reference) to a TYPE_DECL for the class, not a
3664 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3665 or one of its enclosing classes, and that type is a template,
3666 return the associated TEMPLATE_DECL. Otherwise, the original
3667 DECL is returned. */
3670 maybe_get_template_decl_from_type_decl (decl)
3673 return (decl != NULL_TREE
3674 && TREE_CODE (decl) == TYPE_DECL
3675 && DECL_ARTIFICIAL (decl)
3676 && CLASS_TYPE_P (TREE_TYPE (decl))
3677 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
3678 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
3681 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3682 parameters, find the desired type.
3684 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3685 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3686 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3687 otherwise.) Since ARGLIST is build on the decl_obstack, we must
3688 copy it here to keep it from being reclaimed when the decl storage
3691 IN_DECL, if non-NULL, is the template declaration we are trying to
3694 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3695 the class we are looking up.
3697 If the template class is really a local class in a template
3698 function, then the FUNCTION_CONTEXT is the function in which it is
3699 being instantiated. */
3702 lookup_template_class (d1, arglist, in_decl, context, entering_scope)
3708 tree template = NULL_TREE, parmlist;
3711 if (TREE_CODE (d1) == IDENTIFIER_NODE)
3713 if (IDENTIFIER_VALUE (d1)
3714 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1)))
3715 template = IDENTIFIER_VALUE (d1);
3719 push_decl_namespace (context);
3720 template = lookup_name (d1, /*prefer_type=*/0);
3721 template = maybe_get_template_decl_from_type_decl (template);
3723 pop_decl_namespace ();
3726 context = DECL_CONTEXT (template);
3728 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
3730 tree type = TREE_TYPE (d1);
3732 /* If we are declaring a constructor, say A<T>::A<T>, we will get
3733 an implicit typename for the second A. Deal with it. */
3734 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
3735 type = TREE_TYPE (type);
3737 if (CLASSTYPE_TEMPLATE_INFO (type))
3739 template = CLASSTYPE_TI_TEMPLATE (type);
3740 d1 = DECL_NAME (template);
3743 else if (TREE_CODE (d1) == ENUMERAL_TYPE
3744 || (TREE_CODE_CLASS (TREE_CODE (d1)) == 't'
3745 && IS_AGGR_TYPE (d1)))
3747 template = TYPE_TI_TEMPLATE (d1);
3748 d1 = DECL_NAME (template);
3750 else if (TREE_CODE (d1) == TEMPLATE_DECL
3751 && TREE_CODE (DECL_RESULT (d1)) == TYPE_DECL)
3754 d1 = DECL_NAME (template);
3755 context = DECL_CONTEXT (template);
3758 my_friendly_abort (272);
3760 /* With something like `template <class T> class X class X { ... };'
3761 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3762 We don't want to do that, but we have to deal with the situation,
3763 so let's give them some syntax errors to chew on instead of a
3767 cp_error ("`%T' is not a template", d1);
3768 return error_mark_node;
3771 if (context == NULL_TREE)
3772 context = global_namespace;
3774 if (TREE_CODE (template) != TEMPLATE_DECL)
3776 cp_error ("non-template type `%T' used as a template", d1);
3778 cp_error_at ("for template declaration `%D'", in_decl);
3779 return error_mark_node;
3782 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
3784 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3785 template arguments */
3787 tree parm = copy_template_template_parm (TREE_TYPE (template));
3788 tree template2 = TYPE_STUB_DECL (parm);
3791 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
3793 arglist2 = coerce_template_parms (parmlist, arglist, template, 1, 1);
3794 if (arglist2 == error_mark_node)
3795 return error_mark_node;
3797 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm)
3798 = tree_cons (template2, arglist2, NULL_TREE);
3799 TYPE_SIZE (parm) = 0;
3804 tree template_type = TREE_TYPE (template);
3807 tree found = NULL_TREE;
3810 int is_partial_instantiation;
3812 gen_tmpl = most_general_template (template);
3813 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
3814 parm_depth = TMPL_PARMS_DEPTH (parmlist);
3815 arg_depth = TMPL_ARGS_DEPTH (arglist);
3817 /* We build up the coerced arguments and such on the
3818 momentary_obstack. */
3821 if (arg_depth == 1 && parm_depth > 1)
3823 /* We've been given an incomplete set of template arguments.
3826 template <class T> struct S1 {
3827 template <class U> struct S2 {};
3828 template <class U> struct S2<U*> {};
3831 we will be called with an ARGLIST of `U*', but the
3832 TEMPLATE will be `template <class T> template
3833 <class U> struct S1<T>::S2'. We must fill in the missing
3836 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
3838 arg_depth = TMPL_ARGS_DEPTH (arglist);
3841 /* Now we should enough arguments. */
3842 my_friendly_assert (parm_depth == arg_depth, 0);
3844 /* From here on, we're only interested in the most general
3846 template = gen_tmpl;
3848 /* Calculate the BOUND_ARGS. These will be the args that are
3849 actually tsubst'd into the definition to create the
3853 /* We have multiple levels of arguments to coerce, at once. */
3855 int saved_depth = TMPL_ARGS_DEPTH (arglist);
3857 tree bound_args = make_temp_vec (parm_depth);
3859 for (i = saved_depth,
3860 t = DECL_TEMPLATE_PARMS (template);
3861 i > 0 && t != NULL_TREE;
3862 --i, t = TREE_CHAIN (t))
3864 tree a = coerce_template_parms (TREE_VALUE (t),
3865 arglist, template, 1, 1);
3866 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
3868 /* We temporarily reduce the length of the ARGLIST so
3869 that coerce_template_parms will see only the arguments
3870 corresponding to the template parameters it is
3872 TREE_VEC_LENGTH (arglist)--;
3875 /* Restore the ARGLIST to its full size. */
3876 TREE_VEC_LENGTH (arglist) = saved_depth;
3878 arglist = bound_args;
3882 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
3883 innermost_args (arglist),
3886 if (arglist == error_mark_node)
3887 /* We were unable to bind the arguments. */
3888 return error_mark_node;
3890 /* In the scope of a template class, explicit references to the
3891 template class refer to the type of the template, not any
3892 instantiation of it. For example, in:
3894 template <class T> class C { void f(C<T>); }
3896 the `C<T>' is just the same as `C'. Outside of the
3897 class, however, such a reference is an instantiation. */
3898 if (comp_template_args (TYPE_TI_ARGS (template_type),
3901 found = template_type;
3903 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
3907 /* Note that we use DECL_CONTEXT, rather than
3908 CP_DECL_CONTEXT, so that the termination test is
3909 always just `ctx'. We're not interested in namepace
3911 for (ctx = current_class_type;
3913 ctx = (TREE_CODE_CLASS (TREE_CODE (ctx)) == 't')
3914 ? TYPE_CONTEXT (ctx) : DECL_CONTEXT (ctx))
3915 if (same_type_p (ctx, template_type))
3919 /* We're not in the scope of the class, so the
3920 TEMPLATE_TYPE is not the type we want after
3928 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
3929 found; found = TREE_CHAIN (found))
3930 if (comp_template_args (TREE_PURPOSE (found), arglist))
3934 found = TREE_VALUE (found);
3943 /* This type is a "partial instantiation" if any of the template
3944 arguments still inolve template parameters. Note that we set
3945 IS_PARTIAL_INSTANTIATION for partial specializations as
3947 is_partial_instantiation = uses_template_parms (arglist);
3949 if (!is_partial_instantiation
3950 && !PRIMARY_TEMPLATE_P (template)
3951 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
3954 found = xref_tag_from_type (TREE_TYPE (template),
3955 DECL_NAME (template),
3960 /* Since we didn't find the type, we'll have to create it.
3961 Since we'll be saving this type on the
3962 DECL_TEMPLATE_INSTANTIATIONS list, it must be permanent. */
3963 push_obstacks (&permanent_obstack, &permanent_obstack);
3965 /* Create the type. */
3966 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
3968 if (!is_partial_instantiation)
3969 t = start_enum (TYPE_IDENTIFIER (template_type));
3971 /* We don't want to call start_enum for this type, since
3972 the values for the enumeration constants may involve
3973 template parameters. And, no one should be interested
3974 in the enumeration constants for such a type. */
3975 t = make_node (ENUMERAL_TYPE);
3979 t = make_lang_type (TREE_CODE (template_type));
3980 CLASSTYPE_DECLARED_CLASS (t)
3981 = CLASSTYPE_DECLARED_CLASS (template_type);
3982 CLASSTYPE_GOT_SEMICOLON (t) = 1;
3983 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
3984 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
3987 /* If we called start_enum above, this information will already
3991 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3993 type_decl = create_implicit_typedef (DECL_NAME (template), t);
3994 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
3995 TYPE_STUB_DECL (t) = type_decl;
3996 DECL_SOURCE_FILE (type_decl)
3997 = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type));
3998 DECL_SOURCE_LINE (type_decl)
3999 = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type));
4002 type_decl = TYPE_NAME (t);
4004 /* Set up the template information. We have to figure out which
4005 template is the immediate parent if this is a full
4007 if (parm_depth == 1 || is_partial_instantiation
4008 || !PRIMARY_TEMPLATE_P (template))
4009 /* This case is easy; there are no member templates involved. */
4013 /* This is a full instantiation of a member template. There
4014 should be some partial instantiation of which this is an
4017 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4018 found; found = TREE_CHAIN (found))
4021 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4023 /* We only want partial instantiations, here, not
4024 specializations or full instantiations. */
4025 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4026 || !uses_template_parms (TREE_VALUE (found)))
4029 /* Temporarily reduce by one the number of levels in the
4030 ARGLIST and in FOUND so as to avoid comparing the
4031 last set of arguments. */
4032 TREE_VEC_LENGTH (arglist)--;
4033 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4035 /* See if the arguments match. If they do, then TMPL is
4036 the partial instantiation we want. */
4037 success = comp_template_args (TREE_PURPOSE (found), arglist);
4039 /* Restore the argument vectors to their full size. */
4040 TREE_VEC_LENGTH (arglist)++;
4041 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4051 my_friendly_abort (0);
4054 SET_TYPE_TEMPLATE_INFO (t,
4055 tree_cons (found, arglist, NULL_TREE));
4056 DECL_TEMPLATE_INSTANTIATIONS (template)
4057 = tree_cons (arglist, t,
4058 DECL_TEMPLATE_INSTANTIATIONS (template));
4060 if (TREE_CODE (t) == ENUMERAL_TYPE
4061 && !is_partial_instantiation)
4062 /* Now that the type has been registered on the instantiations
4063 list, we set up the enumerators. Because the enumeration
4064 constants may involve the enumeration type itself, we make
4065 sure to register the type first, and then create the
4066 constants. That way, doing tsubst_expr for the enumeration
4067 constants won't result in recursive calls here; we'll find
4068 the instantiation and exit above. */
4069 tsubst_enum (template_type, t, arglist);
4071 /* We're done with the permanent obstack, now. */
4073 /* We're also done with the momentary allocation we started
4077 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4079 if (TREE_CODE (t) != ENUMERAL_TYPE)
4080 DECL_NAME (type_decl) = classtype_mangled_name (t);
4081 DECL_ASSEMBLER_NAME (type_decl) = DECL_NAME (type_decl);
4082 if (!is_partial_instantiation)
4084 DECL_ASSEMBLER_NAME (type_decl)
4085 = get_identifier (build_overload_name (t, 1, 1));
4087 /* For backwards compatibility; code that uses
4088 -fexternal-templates expects looking up a template to
4089 instantiate it. I think DDD still relies on this.
4090 (jason 8/20/1998) */
4091 if (TREE_CODE (t) != ENUMERAL_TYPE
4092 && flag_external_templates
4093 && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template))
4094 && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template)))
4095 add_pending_template (t);
4098 /* If the type makes use of template parameters, the
4099 code that generates debugging information will crash. */
4100 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4106 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, or
4107 TEMPLATE_PARM_INDEX in T, call FN with the parameter and the DATA.
4108 If FN returns non-zero, the iteration is terminated, and
4109 for_each_template_parm returns 1. Otherwise, the iteration
4110 continues. If FN never returns a non-zero value, the value
4111 returned by for_each_template_parm is 0. If FN is NULL, it is
4112 considered to be the function which always returns 1. */
4115 for_each_template_parm (t, fn, data)
4123 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't'
4124 && for_each_template_parm (TYPE_CONTEXT (t), fn, data))
4127 switch (TREE_CODE (t))
4131 return (for_each_template_parm (TREE_OPERAND (t, 0), fn, data)
4132 || for_each_template_parm (TREE_OPERAND (t, 1), fn, data));
4134 case IDENTIFIER_NODE:
4135 if (!IDENTIFIER_TEMPLATE (t))
4137 my_friendly_abort (42);
4139 /* aggregates of tree nodes */
4142 int i = TREE_VEC_LENGTH (t);
4144 if (for_each_template_parm (TREE_VEC_ELT (t, i), fn, data))
4149 if (for_each_template_parm (TREE_PURPOSE (t), fn, data)
4150 || for_each_template_parm (TREE_VALUE (t), fn, data))
4152 return for_each_template_parm (TREE_CHAIN (t), fn, data);
4155 if (for_each_template_parm (OVL_FUNCTION (t), fn, data))
4157 return for_each_template_parm (OVL_CHAIN (t), fn, data);
4159 /* constructed type nodes */
4161 case REFERENCE_TYPE:
4162 return for_each_template_parm (TREE_TYPE (t), fn, data);
4165 if (TYPE_PTRMEMFUNC_FLAG (t))
4166 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE (t),
4172 if (! TYPE_TEMPLATE_INFO (t))
4174 return for_each_template_parm (TREE_VALUE
4175 (TYPE_TEMPLATE_INFO (t)),
4178 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data))
4183 /* Check the parameter types. Since default arguments are not
4184 instantiated until they are needed, the TYPE_ARG_TYPES may
4185 contain expressions that involve template parameters. But,
4186 no-one should be looking at them yet. And, once they're
4187 instantiated, they don't contain template parameters, so
4188 there's no point in looking at them then, either. */
4192 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4193 if (for_each_template_parm (TREE_VALUE (parm), fn, data))
4197 /* Check the return type, too. */
4198 return for_each_template_parm (TREE_TYPE (t), fn, data);
4201 if (for_each_template_parm (TYPE_DOMAIN (t), fn, data))
4203 return for_each_template_parm (TREE_TYPE (t), fn, data);
4205 if (for_each_template_parm (TYPE_OFFSET_BASETYPE (t), fn, data))
4207 return for_each_template_parm (TREE_TYPE (t), fn, data);
4211 return for_each_template_parm (TREE_TYPE (t), fn, data);
4214 /* A template template parameter is encountered */
4215 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
4216 return for_each_template_parm (TREE_TYPE (t), fn, data);
4217 /* Already substituted template template parameter */
4221 if (for_each_template_parm (DECL_INITIAL (t), fn, data))
4223 goto check_type_and_context;
4227 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
4228 && for_each_template_parm (DECL_TI_ARGS (t), fn, data))
4232 check_type_and_context:
4233 if (for_each_template_parm (TREE_TYPE (t), fn, data))
4235 if (DECL_CONTEXT (t)
4236 && for_each_template_parm (DECL_CONTEXT (t), fn, data))
4241 return (for_each_template_parm (TREE_OPERAND (t, 0), fn, data)
4242 || for_each_template_parm (TREE_OPERAND (t, 1), fn, data));
4245 return for_each_template_parm (TREE_OPERAND (t, 0), fn, data);
4247 /* template parm nodes */
4248 case TEMPLATE_TEMPLATE_PARM:
4249 /* Record template parameters such as `T' inside `TT<T>'. */
4250 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t)
4251 && for_each_template_parm (TYPE_TI_ARGS (t), fn, data))
4253 case TEMPLATE_TYPE_PARM:
4254 case TEMPLATE_PARM_INDEX:
4256 return (*fn)(t, data);
4260 /* simple type nodes */
4262 if (for_each_template_parm (TYPE_MIN_VALUE (t), fn, data))
4264 return for_each_template_parm (TYPE_MAX_VALUE (t), fn, data);
4270 case NAMESPACE_DECL:
4281 /* Non-error_mark_node ERROR_MARKs are bad things. */
4282 my_friendly_assert (t == error_mark_node, 274);
4287 return for_each_template_parm (TREE_TYPE (t), fn, data);
4290 return for_each_template_parm (TREE_OPERAND (t, 0), fn, data);
4293 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
4294 return for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4295 (TREE_TYPE (t)), fn, data);
4296 return for_each_template_parm (TREE_OPERAND (t, 1), fn, data);
4300 return for_each_template_parm (TREE_OPERAND (t, 0), fn, data);
4305 return (for_each_template_parm (TYPE_CONTEXT (t), fn, data)
4306 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t),
4311 /* If there's no type, then this thing must be some expression
4312 involving template parameters. */
4313 if (!fn && !TREE_TYPE (t))
4315 if (TREE_CODE (t) == COMPONENT_REF)
4316 return (for_each_template_parm (TREE_OPERAND (t, 0), fn, data)
4317 || for_each_template_parm (TREE_OPERAND (t, 1), fn, data));
4319 return for_each_template_parm (TREE_OPERAND (t, 0), fn, data);
4323 case REINTERPRET_CAST_EXPR:
4324 case CONST_CAST_EXPR:
4325 case STATIC_CAST_EXPR:
4326 case DYNAMIC_CAST_EXPR:
4331 case PSEUDO_DTOR_EXPR:
4337 switch (TREE_CODE_CLASS (TREE_CODE (t)))
4345 for (i = first_rtl_op (TREE_CODE (t)); --i >= 0;)
4346 if (for_each_template_parm (TREE_OPERAND (t, i), fn, data))
4353 sorry ("testing %s for template parms",
4354 tree_code_name [(int) TREE_CODE (t)]);
4355 my_friendly_abort (82);
4362 uses_template_parms (t)
4365 return for_each_template_parm (t, 0, 0);
4368 static struct tinst_level *current_tinst_level;
4369 static struct tinst_level *free_tinst_level;
4370 static int tinst_depth;
4371 extern int max_tinst_depth;
4372 #ifdef GATHER_STATISTICS
4375 int tinst_level_tick;
4376 int last_template_error_tick;
4378 /* Print out all the template instantiations that we are currently
4379 working on. If ERR, we are being called from cp_thing, so do
4380 the right thing for an error message. */
4383 print_template_context (err)
4386 struct tinst_level *p = current_tinst_level;
4388 char *file = input_filename;
4392 if (current_function_decl != p->decl
4393 && current_function_decl != NULL_TREE)
4394 /* We can get here during the processing of some synthesized
4395 method. Then, p->decl will be the function that's causing
4400 if (current_function_decl == p->decl)
4401 /* Avoid redundancy with the the "In function" line. */;
4403 fprintf (stderr, "%s: In instantiation of `%s':\n",
4404 file, decl_as_string (p->decl, 0));
4412 for (; p; p = p->next)
4414 fprintf (stderr, "%s:%d: instantiated from `%s'\n", file, line,
4415 decl_as_string (p->decl, 0));
4419 fprintf (stderr, "%s:%d: instantiated from here\n", file, line);
4422 /* Called from cp_thing to print the template context for an error. */
4425 maybe_print_template_context ()
4427 if (last_template_error_tick == tinst_level_tick
4428 || current_tinst_level == 0)
4431 last_template_error_tick = tinst_level_tick;
4432 print_template_context (1);
4436 push_tinst_level (d)
4439 struct tinst_level *new;
4441 if (tinst_depth >= max_tinst_depth)
4443 /* If the instantiation in question still has unbound template parms,
4444 we don't really care if we can't instantiate it, so just return.
4445 This happens with base instantiation for implicit `typename'. */
4446 if (uses_template_parms (d))
4449 last_template_error_tick = tinst_level_tick;
4450 error ("template instantiation depth exceeds maximum of %d",
4452 error (" (use -ftemplate-depth-NN to increase the maximum)");
4453 cp_error (" instantiating `%D'", d);
4455 print_template_context (0);
4460 if (free_tinst_level)
4462 new = free_tinst_level;
4463 free_tinst_level = new->next;
4466 new = (struct tinst_level *) xmalloc (sizeof (struct tinst_level));
4470 new->file = input_filename;
4471 new->next = current_tinst_level;
4472 current_tinst_level = new;
4475 #ifdef GATHER_STATISTICS
4476 if (tinst_depth > depth_reached)
4477 depth_reached = tinst_depth;
4487 struct tinst_level *old = current_tinst_level;
4489 /* Restore the filename and line number stashed away when we started
4490 this instantiation. */
4492 input_filename = old->file;
4493 extract_interface_info ();
4495 current_tinst_level = old->next;
4496 old->next = free_tinst_level;
4497 free_tinst_level = old;
4502 struct tinst_level *
4505 struct tinst_level *p = current_tinst_level;
4508 for (; p->next ; p = p->next )
4513 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4514 vector of template arguments, as for tsubst.
4516 Returns an appropriate tsbust'd friend declaration. */
4519 tsubst_friend_function (decl, args)
4525 char *file = input_filename;
4527 lineno = DECL_SOURCE_LINE (decl);
4528 input_filename = DECL_SOURCE_FILE (decl);
4530 if (TREE_CODE (decl) == FUNCTION_DECL
4531 && DECL_TEMPLATE_INSTANTIATION (decl)
4532 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
4533 /* This was a friend declared with an explicit template
4534 argument list, e.g.:
4538 to indicate that f was a template instantiation, not a new
4539 function declaration. Now, we have to figure out what
4540 instantiation of what template. */
4547 = lookup_template_function (tsubst_expr (DECL_TI_TEMPLATE (decl),
4548 args, /*complain=*/1,
4550 tsubst (DECL_TI_ARGS (decl),
4551 args, /*complain=*/1,
4553 /* FIXME: The decl we create via the next tsubst could be
4554 created on a temporary obstack. */
4555 new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE);
4556 tmpl = determine_specialization (template_id, new_friend,
4558 /*need_member_template=*/0);
4559 new_friend = instantiate_template (tmpl, new_args);
4563 new_friend = tsubst (decl, args, /*complain=*/1, NULL_TREE);
4565 /* The NEW_FRIEND will look like an instantiation, to the
4566 compiler, but is not an instantiation from the point of view of
4567 the language. For example, we might have had:
4569 template <class T> struct S {
4570 template <class U> friend void f(T, U);
4573 Then, in S<int>, template <class U> void f(int, U) is not an
4574 instantiation of anything. */
4575 DECL_USE_TEMPLATE (new_friend) = 0;
4576 if (TREE_CODE (decl) == TEMPLATE_DECL)
4577 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
4579 /* The mangled name for the NEW_FRIEND is incorrect. The call to
4580 tsubst will have resulted in a call to
4581 set_mangled_name_for_template_decl. But, the function is not a
4582 template instantiation and should not be mangled like one.
4583 Therefore, we remangle the function name. We don't have to do
4584 this if the NEW_FRIEND is a template since
4585 set_mangled_name_for_template_decl doesn't do anything if the
4586 function declaration still uses template arguments. */
4587 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
4589 set_mangled_name_for_decl (new_friend);
4590 DECL_RTL (new_friend) = 0;
4591 make_decl_rtl (new_friend, NULL_PTR, 1);
4594 if (DECL_NAMESPACE_SCOPE_P (new_friend))
4597 tree new_friend_template_info;
4598 tree new_friend_result_template_info;
4600 int new_friend_is_defn;
4602 /* We must save some information from NEW_FRIEND before calling
4603 duplicate decls since that function will free NEW_FRIEND if
4605 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
4606 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
4608 /* This declaration is a `primary' template. */
4609 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
4612 = DECL_INITIAL (DECL_RESULT (new_friend)) != NULL_TREE;
4613 new_friend_result_template_info
4614 = DECL_TEMPLATE_INFO (DECL_RESULT (new_friend));
4618 new_friend_is_defn = DECL_INITIAL (new_friend) != NULL_TREE;
4619 new_friend_result_template_info = NULL_TREE;
4622 /* Inside pushdecl_namespace_level, we will push into the
4623 current namespace. However, the friend function should
4624 tyically go into the namespace of the template. */
4625 ns = decl_namespace_context (new_friend);
4626 push_nested_namespace (ns);
4627 old_decl = pushdecl_namespace_level (new_friend);
4628 pop_nested_namespace (ns);
4630 if (old_decl != new_friend)
4632 /* This new friend declaration matched an existing
4633 declaration. For example, given:
4635 template <class T> void f(T);
4636 template <class U> class C {
4637 template <class T> friend void f(T) {}
4640 the friend declaration actually provides the definition
4641 of `f', once C has been instantiated for some type. So,
4642 old_decl will be the out-of-class template declaration,
4643 while new_friend is the in-class definition.
4645 But, if `f' was called before this point, the
4646 instantiation of `f' will have DECL_TI_ARGS corresponding
4647 to `T' but not to `U', references to which might appear
4648 in the definition of `f'. Previously, the most general
4649 template for an instantiation of `f' was the out-of-class
4650 version; now it is the in-class version. Therefore, we
4651 run through all specialization of `f', adding to their
4652 DECL_TI_ARGS appropriately. In particular, they need a
4653 new set of outer arguments, corresponding to the
4654 arguments for this class instantiation.
4656 The same situation can arise with something like this:
4659 template <class T> class C {
4663 when `C<int>' is instantiated. Now, `f(int)' is defined
4666 if (!new_friend_is_defn)
4667 /* On the other hand, if the in-class declaration does
4668 *not* provide a definition, then we don't want to alter
4669 existing definitions. We can just leave everything
4674 /* Overwrite whatever template info was there before, if
4675 any, with the new template information pertaining to
4677 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
4679 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
4680 /* duplicate_decls will take care of this case. */
4685 tree new_friend_args;
4687 DECL_TEMPLATE_INFO (DECL_RESULT (old_decl))
4688 = new_friend_result_template_info;
4690 new_friend_args = TI_ARGS (new_friend_template_info);
4691 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
4695 tree spec = TREE_VALUE (t);
4698 = add_outermost_template_args (new_friend_args,
4699 DECL_TI_ARGS (spec));
4702 /* Now, since specializations are always supposed to
4703 hang off of the most general template, we must move
4705 t = most_general_template (old_decl);
4708 DECL_TEMPLATE_SPECIALIZATIONS (t)
4709 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
4710 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
4711 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
4716 /* The information from NEW_FRIEND has been merged into OLD_DECL
4717 by duplicate_decls. */
4718 new_friend = old_decl;
4721 else if (TYPE_SIZE (DECL_CONTEXT (new_friend)))
4723 /* Check to see that the declaration is really present, and,
4724 possibly obtain an improved declaration. */
4725 tree fn = check_classfn (DECL_CONTEXT (new_friend),
4734 input_filename = file;
4738 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4739 template arguments, as for tsubst.
4741 Returns an appropriate tsbust'd friend type. */
4744 tsubst_friend_class (friend_tmpl, args)
4751 /* First, we look for a class template. */
4752 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0);
4754 /* But, if we don't find one, it might be because we're in a
4755 situation like this:
4763 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
4764 for `S<int>', not the TEMPLATE_DECL. */
4765 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
4767 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1);
4768 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
4771 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
4773 /* The friend template has already been declared. Just
4774 check to see that the declarations match, and install any new
4775 default parameters. We must tsubst the default parameters,
4776 of course. We only need the innermost template parameters
4777 because that is all that redeclare_class_template will look
4780 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
4781 args, /*complain=*/1);
4782 redeclare_class_template (TREE_TYPE (tmpl), parms);
4783 friend_type = TREE_TYPE (tmpl);
4787 /* The friend template has not already been declared. In this
4788 case, the instantiation of the template class will cause the
4789 injection of this template into the global scope. */
4790 tmpl = tsubst (friend_tmpl, args, /*complain=*/1, NULL_TREE);
4792 /* The new TMPL is not an instantiation of anything, so we
4793 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4794 the new type because that is supposed to be the corresponding
4795 template decl, i.e., TMPL. */
4796 DECL_USE_TEMPLATE (tmpl) = 0;
4797 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
4798 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
4800 /* Inject this template into the global scope. */
4801 friend_type = TREE_TYPE (pushdecl_top_level (tmpl));
4808 instantiate_class_template (type)
4811 tree template, args, pattern, t;
4814 if (type == error_mark_node)
4815 return error_mark_node;
4817 if (TYPE_BEING_DEFINED (type) || TYPE_SIZE (type))
4820 /* We want to allocate temporary vectors of template arguments and
4821 template argument expressions on the momentary obstack, not on
4822 the expression obstack. Otherwise, all the space allocated in
4823 argument coercion and such is simply lost. */
4826 /* Figure out which template is being instantiated. */
4827 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
4828 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279);
4830 /* Figure out which arguments are being used to do the
4832 args = CLASSTYPE_TI_ARGS (type);
4833 PARTIAL_INSTANTIATION_P (type) = uses_template_parms (args);
4835 if (pedantic && PARTIAL_INSTANTIATION_P (type))
4836 /* If this is a partial instantiation, then we can't instantiate
4837 the type; there's no telling whether or not one of the
4838 template parameters might eventually be instantiated to some
4839 value that results in a specialization being used. For
4851 Now, the `S<U>' in `f<int>' is the specialization, not an
4852 instantiation of the original template. */
4855 /* Determine what specialization of the original template to
4857 if (PARTIAL_INSTANTIATION_P (type))
4858 /* There's no telling which specialization is appropriate at this
4859 point. Since all peeking at the innards of this partial
4860 instantiation are extensions (like the "implicit typename"
4861 extension, which allows users to omit the keyword `typename' on
4862 names that are declared as types in template base classes), we
4863 are free to do what we please.
4865 Trying to figure out which partial instantiation to use can
4866 cause a crash. (Some of the template arguments don't even have
4867 types.) So, we just use the most general version. */
4871 t = most_specialized_class (template, args);
4873 if (t == error_mark_node)
4875 const char *str = "candidates are:";
4876 cp_error ("ambiguous class template instantiation for `%#T'", type);
4877 for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t;
4880 if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t),
4883 cp_error_at ("%s %+#T", str, TREE_TYPE (t));
4887 TYPE_BEING_DEFINED (type) = 1;
4888 type = error_mark_node;
4894 pattern = TREE_TYPE (t);
4896 pattern = TREE_TYPE (template);
4898 /* If the template we're instantiating is incomplete, then clearly
4899 there's nothing we can do. */
4900 if (TYPE_SIZE (pattern) == NULL_TREE)
4903 /* If this is a partial instantiation, don't tsubst anything. We will
4904 only use this type for implicit typename, so the actual contents don't
4905 matter. All that matters is whether a particular name is a type. */
4906 if (PARTIAL_INSTANTIATION_P (type))
4908 /* The fields set here must be kept in sync with those cleared
4909 in begin_class_definition. */
4910 TYPE_BINFO_BASETYPES (type) = TYPE_BINFO_BASETYPES (pattern);
4911 TYPE_FIELDS (type) = TYPE_FIELDS (pattern);
4912 TYPE_METHODS (type) = TYPE_METHODS (pattern);
4913 CLASSTYPE_TAGS (type) = CLASSTYPE_TAGS (pattern);
4914 /* Pretend that the type is complete, so that we will look
4915 inside it during name lookup and such. */
4916 TYPE_SIZE (type) = integer_zero_node;
4920 /* If we've recursively instantiated too many templates, stop. */
4921 if (! push_tinst_level (type))
4924 /* Now we're really doing the instantiation. Mark the type as in
4925 the process of being defined. */
4926 TYPE_BEING_DEFINED (type) = 1;
4928 maybe_push_to_top_level (uses_template_parms (type));
4932 /* This TYPE is actually a instantiation of of a partial
4933 specialization. We replace the innermost set of ARGS with
4934 the arguments appropriate for substitution. For example,
4937 template <class T> struct S {};
4938 template <class T> struct S<T*> {};
4940 and supposing that we are instantiating S<int*>, ARGS will
4941 present be {int*} but we need {int}. */
4943 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t),
4946 /* If there were multiple levels in ARGS, replacing the
4947 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4948 want, so we make a copy first. */
4949 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
4951 args = copy_node (args);
4952 SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args);
4958 if (flag_external_templates)
4960 if (flag_alt_external_templates)
4962 CLASSTYPE_INTERFACE_ONLY (type) = interface_only;
4963 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type, interface_unknown);
4964 CLASSTYPE_VTABLE_NEEDS_WRITING (type)
4965 = (! CLASSTYPE_INTERFACE_ONLY (type)
4966 && CLASSTYPE_INTERFACE_KNOWN (type));
4970 CLASSTYPE_INTERFACE_ONLY (type) = CLASSTYPE_INTERFACE_ONLY (pattern);
4971 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
4972 (type, CLASSTYPE_INTERFACE_UNKNOWN (pattern));
4973 CLASSTYPE_VTABLE_NEEDS_WRITING (type)
4974 = (! CLASSTYPE_INTERFACE_ONLY (type)
4975 && CLASSTYPE_INTERFACE_KNOWN (type));
4980 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
4981 CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
4984 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
4985 TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern);
4986 TYPE_OVERLOADS_CALL_EXPR (type) = TYPE_OVERLOADS_CALL_EXPR (pattern);
4987 TYPE_OVERLOADS_ARRAY_REF (type) = TYPE_OVERLOADS_ARRAY_REF (pattern);
4988 TYPE_OVERLOADS_ARROW (type) = TYPE_OVERLOADS_ARROW (pattern);
4989 TYPE_GETS_NEW (type) = TYPE_GETS_NEW (pattern);
4990 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
4991 TYPE_VEC_DELETE_TAKES_SIZE (type) = TYPE_VEC_DELETE_TAKES_SIZE (pattern);
4992 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
4993 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
4994 TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern);
4995 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
4996 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
4997 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
4998 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
4999 TYPE_USES_COMPLEX_INHERITANCE (type)
5000 = TYPE_USES_COMPLEX_INHERITANCE (pattern);
5001 TYPE_USES_MULTIPLE_INHERITANCE (type)
5002 = TYPE_USES_MULTIPLE_INHERITANCE (pattern);
5003 TYPE_USES_VIRTUAL_BASECLASSES (type)
5004 = TYPE_USES_VIRTUAL_BASECLASSES (pattern);
5005 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5006 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5007 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5008 if (ANON_AGGR_TYPE_P (pattern))
5009 SET_ANON_AGGR_TYPE_P (type);
5011 if (TYPE_BINFO_BASETYPES (pattern))
5013 tree base_list = NULL_TREE;
5014 tree pbases = TYPE_BINFO_BASETYPES (pattern);
5017 /* Substitute into each of the bases to determine the actual
5019 for (i = 0; i < TREE_VEC_LENGTH (pbases); ++i)
5025 pbase = TREE_VEC_ELT (pbases, i);
5027 /* Substitue to figure out the base class. */
5028 base = tsubst (BINFO_TYPE (pbase), args,
5029 /*complain=*/1, NULL_TREE);
5030 if (base == error_mark_node)
5033 /* Calculate the correct access node. */
5034 if (TREE_VIA_VIRTUAL (pbase))
5036 if (TREE_VIA_PUBLIC (pbase))
5037 access = access_public_virtual_node;
5038 else if (TREE_VIA_PROTECTED (pbase))
5039 access = access_protected_virtual_node;
5041 access = access_private_virtual_node;
5045 if (TREE_VIA_PUBLIC (pbase))
5046 access = access_public_node;
5047 else if (TREE_VIA_PROTECTED (pbase))
5048 access = access_protected_node;
5050 access = access_private_node;
5053 base_list = tree_cons (access, base, base_list);
5056 /* The list is now in reverse order; correct that. */
5057 base_list = nreverse (base_list);
5059 /* Now call xref_basetypes to set up all the base-class
5061 xref_basetypes (TREE_CODE (pattern) == RECORD_TYPE
5062 ? (CLASSTYPE_DECLARED_CLASS (pattern)
5063 ? class_type_node : record_type_node)
5065 DECL_NAME (TYPE_NAME (pattern)),
5070 /* Now that our base classes are set up, enter the scope of the
5071 class, so that name lookups into base classes, etc. will work
5072 corectly. This is precisely analagous to what we do in
5073 begin_class_definition when defining an ordinary non-template
5075 pushclass (type, 1);
5077 for (t = CLASSTYPE_TAGS (pattern); t; t = TREE_CHAIN (t))
5079 tree tag = TREE_VALUE (t);
5080 tree name = TYPE_IDENTIFIER (tag);
5083 newtag = tsubst (tag, args, /*complain=*/1, NULL_TREE);
5084 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5086 if (TYPE_LANG_SPECIFIC (tag) && CLASSTYPE_IS_TEMPLATE (tag))
5087 /* Unfortunately, lookup_template_class sets
5088 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5089 instantiation (i.e., for the type of a member template
5090 class nested within a template class.) This behavior is
5091 required for maybe_process_partial_specialization to work
5092 correctly, but is not accurate in this case; the TAG is not
5093 an instantiation of anything. (The corresponding
5094 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
5095 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5097 /* Now, we call pushtag to put this NEWTAG into the scope of
5098 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5099 pushtag calling push_template_decl. We don't have to do
5100 this for enums because it will already have been done in
5103 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5104 pushtag (name, newtag, /*globalize=*/0);
5108 /* Don't replace enum constants here. */
5109 for (t = TYPE_FIELDS (pattern); t; t = TREE_CHAIN (t))
5110 if (TREE_CODE (t) != CONST_DECL)
5114 /* The the file and line for this declaration, to assist in
5115 error message reporting. Since we called push_tinst_level
5116 above, we don't need to restore these. */
5117 lineno = DECL_SOURCE_LINE (t);
5118 input_filename = DECL_SOURCE_FILE (t);
5120 r = tsubst (t, args, /*complain=*/1, NULL_TREE);
5121 if (TREE_CODE (r) == VAR_DECL)
5125 if (DECL_DEFINED_IN_CLASS_P (r))
5126 init = tsubst_expr (DECL_INITIAL (t), args,
5127 /*complain=*/1, NULL_TREE);
5131 finish_static_data_member_decl (r, init,
5132 /*asmspec_tree=*/NULL_TREE,
5136 if (DECL_DEFINED_IN_CLASS_P (r))
5137 check_static_variable_definition (r, TREE_TYPE (r));
5140 /* R will have a TREE_CHAIN if and only if it has already been
5141 processed by finish_member_declaration. This can happen
5142 if, for example, it is a TYPE_DECL for a class-scoped
5143 ENUMERAL_TYPE; such a thing will already have been added to
5144 the field list by tsubst_enum above. */
5145 if (!TREE_CHAIN (r))
5147 set_current_access_from_decl (r);
5148 finish_member_declaration (r);
5152 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
5153 for this instantiation. */
5154 for (t = TYPE_METHODS (pattern); t; t = TREE_CHAIN (t))
5156 tree r = tsubst (t, args, /*complain=*/1, NULL_TREE);
5157 set_current_access_from_decl (r);
5158 finish_member_declaration (r);
5161 /* Construct the DECL_FRIENDLIST for the new class type. */
5162 typedecl = TYPE_MAIN_DECL (type);
5163 for (t = DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern));
5169 for (friends = TREE_VALUE (t);
5170 friends != NULL_TREE;
5171 friends = TREE_CHAIN (friends))
5172 if (TREE_PURPOSE (friends) == error_mark_node)
5174 tsubst_friend_function (TREE_VALUE (friends),
5178 tsubst_copy (TREE_PURPOSE (t), args,
5179 /*complain=*/1, NULL_TREE),
5180 tsubst (TREE_PURPOSE (friends), args,
5181 /*complain=*/1, NULL_TREE));
5184 for (t = CLASSTYPE_FRIEND_CLASSES (pattern);
5188 tree friend_type = TREE_VALUE (t);
5189 tree new_friend_type;
5191 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5192 new_friend_type = tsubst_friend_class (friend_type, args);
5193 else if (uses_template_parms (friend_type))
5194 new_friend_type = tsubst (friend_type, args, /*complain=*/1,
5198 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
5200 /* The call to xref_tag_from_type does injection for friend
5202 push_nested_namespace (ns);
5204 xref_tag_from_type (friend_type, NULL_TREE, 1);
5205 pop_nested_namespace (ns);
5208 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5209 /* Trick make_friend_class into realizing that the friend
5210 we're adding is a template, not an ordinary class. It's
5211 important that we use make_friend_class since it will
5212 perform some error-checking and output cross-reference
5214 ++processing_template_decl;
5216 make_friend_class (type, new_friend_type);
5218 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5219 --processing_template_decl;
5222 for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
5223 if (TREE_CODE (t) == FIELD_DECL)
5225 TREE_TYPE (t) = complete_type (TREE_TYPE (t));
5226 require_complete_type (t);
5229 /* Set the file and line number information to whatever is given for
5230 the class itself. This puts error messages involving generated
5231 implicit functions at a predictable point, and the same point
5232 that would be used for non-template classes. */
5233 lineno = DECL_SOURCE_LINE (typedecl);
5234 input_filename = DECL_SOURCE_FILE (typedecl);
5236 unreverse_member_declarations (type);
5237 finish_struct_1 (type);
5238 CLASSTYPE_GOT_SEMICOLON (type) = 1;
5240 /* Clear this now so repo_template_used is happy. */
5241 TYPE_BEING_DEFINED (type) = 0;
5242 repo_template_used (type);
5244 /* Now that the class is complete, instantiate default arguments for
5245 any member functions. We don't do this earlier because the
5246 default arguments may reference members of the class. */
5247 if (!PRIMARY_TEMPLATE_P (template))
5248 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
5249 if (TREE_CODE (t) == FUNCTION_DECL
5250 /* Implicitly generated member functions will not have tmplate
5251 information; they are not instantiations, but instead are
5252 created "fresh" for each instantiation. */
5253 && DECL_TEMPLATE_INFO (t))
5254 tsubst_default_arguments (t);
5257 pop_from_top_level ();
5270 if (t1 == NULL_TREE)
5271 return t2 == NULL_TREE;
5272 if (t2 == NULL_TREE)
5274 /* Don't care if one declares its arg const and the other doesn't -- the
5275 main variant of the arg type is all that matters. */
5276 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1))
5277 != TYPE_MAIN_VARIANT (TREE_VALUE (t2)))
5279 return list_eq (TREE_CHAIN (t1), TREE_CHAIN (t2));
5282 /* If arg is a non-type template parameter that does not depend on template
5283 arguments, fold it like we weren't in the body of a template. */
5286 maybe_fold_nontype_arg (arg)
5289 if (TREE_CODE_CLASS (TREE_CODE (arg)) != 't'
5290 && !uses_template_parms (arg))
5292 /* Sometimes, one of the args was an expression involving a
5293 template constant parameter, like N - 1. Now that we've
5294 tsubst'd, we might have something like 2 - 1. This will
5295 confuse lookup_template_class, so we do constant folding
5296 here. We have to unset processing_template_decl, to
5297 fool build_expr_from_tree() into building an actual
5300 int saved_processing_template_decl = processing_template_decl;
5301 processing_template_decl = 0;
5302 arg = fold (build_expr_from_tree (arg));
5303 processing_template_decl = saved_processing_template_decl;
5308 /* Return the TREE_VEC with the arguments for the innermost template header,
5309 where ARGS is either that or the VEC of VECs for all the
5313 innermost_args (args)
5316 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
5319 /* Substitute ARGS into the vector of template arguments T. */
5322 tsubst_template_arg_vector (t, args, complain)
5327 int len = TREE_VEC_LENGTH (t), need_new = 0, i;
5328 tree *elts = (tree *) alloca (len * sizeof (tree));
5330 bzero ((char *) elts, len * sizeof (tree));
5332 for (i = 0; i < len; i++)
5334 if (TREE_VEC_ELT (t, i) != NULL_TREE
5335 && TREE_CODE (TREE_VEC_ELT (t, i)) == TREE_VEC)
5336 elts[i] = tsubst_template_arg_vector (TREE_VEC_ELT (t, i),
5339 elts[i] = maybe_fold_nontype_arg
5340 (tsubst_expr (TREE_VEC_ELT (t, i), args, complain,
5343 if (elts[i] != TREE_VEC_ELT (t, i))
5350 t = make_temp_vec (len);
5351 for (i = 0; i < len; i++)
5352 TREE_VEC_ELT (t, i) = elts[i];
5357 /* Return the result of substituting ARGS into the template parameters
5358 given by PARMS. If there are m levels of ARGS and m + n levels of
5359 PARMS, then the result will contain n levels of PARMS. For
5360 example, if PARMS is `template <class T> template <class U>
5361 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5362 result will be `template <int*, double, class V>'. */
5365 tsubst_template_parms (parms, args, complain)
5373 for (new_parms = &r;
5374 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
5375 new_parms = &(TREE_CHAIN (*new_parms)),
5376 parms = TREE_CHAIN (parms))
5379 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
5382 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
5384 tree default_value =
5385 TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms), i));
5387 TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms), i));
5389 TREE_VEC_ELT (new_vec, i)
5390 = build_tree_list (tsubst (default_value, args, complain,
5392 tsubst (parm_decl, args, complain,
5397 tree_cons (build_int_2 (0, (TMPL_PARMS_DEPTH (parms)
5398 - TMPL_ARGS_DEPTH (args))),
5399 new_vec, NULL_TREE);
5405 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5406 type T. If T is not an aggregate or enumeration type, it is
5407 handled as if by tsubst. IN_DECL is as for tsubst. If
5408 ENTERING_SCOPE is non-zero, T is the context for a template which
5409 we are presently tsubst'ing. Return the subsituted value. */
5412 tsubst_aggr_type (t, args, complain, in_decl, entering_scope)
5422 switch (TREE_CODE (t))
5425 if (TYPE_PTRMEMFUNC_P (t))
5427 tree r = build_ptrmemfunc_type
5428 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl));
5429 return cp_build_qualified_type_real (r, TYPE_QUALS (t),
5433 /* else fall through */
5436 if (TYPE_TEMPLATE_INFO (t))
5442 /* First, determine the context for the type we are looking
5444 if (TYPE_CONTEXT (t) != NULL_TREE)
5445 context = tsubst_aggr_type (TYPE_CONTEXT (t), args,
5447 in_decl, /*entering_scope=*/1);
5449 context = NULL_TREE;
5451 /* Then, figure out what arguments are appropriate for the
5452 type we are trying to find. For example, given:
5454 template <class T> struct S;
5455 template <class T, class U> void f(T, U) { S<U> su; }
5457 and supposing that we are instantiating f<int, double>,
5458 then our ARGS will be {int, double}, but, when looking up
5459 S we only want {double}. */
5461 argvec = tsubst_template_arg_vector (TYPE_TI_ARGS (t), args,
5464 r = lookup_template_class (t, argvec, in_decl, context,
5468 return cp_build_qualified_type_real (r, TYPE_QUALS (t),
5472 /* This is not a template type, so there's nothing to do. */
5476 return tsubst (t, args, complain, in_decl);
5480 /* Substitute into the default argument ARG (a default argument for
5481 FN), which has the indicated TYPE. */
5484 tsubst_default_argument (fn, type, arg)
5489 /* This default argument came from a template. Instantiate the
5490 default argument here, not in tsubst. In the case of
5499 we must be careful to do name lookup in the scope of S<T>,
5500 rather than in the current class. */
5501 if (DECL_CLASS_SCOPE_P (fn))
5502 pushclass (DECL_REAL_CONTEXT (fn), 2);
5504 arg = tsubst_expr (arg, DECL_TI_ARGS (fn), /*complain=*/1, NULL_TREE);
5506 if (DECL_CLASS_SCOPE_P (fn))
5509 /* Make sure the default argument is reasonable. */
5510 arg = check_default_argument (type, arg);
5515 /* Substitute into all the default arguments for FN. */
5518 tsubst_default_arguments (fn)
5524 tmpl_args = DECL_TI_ARGS (fn);
5526 /* If this function is not yet instantiated, we certainly don't need
5527 its default arguments. */
5528 if (uses_template_parms (tmpl_args))
5531 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
5533 arg = TREE_CHAIN (arg))
5534 if (TREE_PURPOSE (arg))
5535 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
5537 TREE_PURPOSE (arg));
5540 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5541 (already computed) substitution of ARGS into TREE_TYPE (T), if
5542 appropriate. Return the result of the substitution. IN_DECL is as
5546 tsubst_decl (t, args, type, in_decl)
5553 char* saved_filename;
5556 /* Set the filename and linenumber to improve error-reporting. */
5557 saved_lineno = lineno;
5558 saved_filename = input_filename;
5559 lineno = DECL_SOURCE_LINE (t);
5560 input_filename = DECL_SOURCE_FILE (t);
5562 switch (TREE_CODE (t))
5566 /* We can get here when processing a member template function
5567 of a template class. */
5568 tree decl = DECL_TEMPLATE_RESULT (t);
5570 int is_template_template_parm = DECL_TEMPLATE_TEMPLATE_PARM_P (t);
5572 if (!is_template_template_parm)
5574 /* We might already have an instance of this template.
5575 The ARGS are for the surrounding class type, so the
5576 full args contain the tsubst'd args for the context,
5577 plus the innermost args from the template decl. */
5578 tree tmpl_args = DECL_CLASS_TEMPLATE_P (t)
5579 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
5580 : DECL_TI_ARGS (DECL_RESULT (t));
5584 full_args = tsubst_template_arg_vector (tmpl_args, args,
5587 /* tsubst_template_arg_vector doesn't copy the vector if
5588 nothing changed. But, *something* should have
5590 my_friendly_assert (full_args != tmpl_args, 0);
5592 spec = retrieve_specialization (t, full_args);
5594 if (spec != NULL_TREE)
5601 /* Make a new template decl. It will be similar to the
5602 original, but will record the current template arguments.
5603 We also create a new function declaration, which is just
5604 like the old one, but points to this new template, rather
5605 than the old one. */
5608 my_friendly_assert (DECL_LANG_SPECIFIC (r) != 0, 0);
5609 TREE_CHAIN (r) = NULL_TREE;
5611 if (is_template_template_parm)
5613 tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl);
5614 DECL_RESULT (r) = new_decl;
5615 TREE_TYPE (r) = TREE_TYPE (new_decl);
5620 = tsubst_aggr_type (DECL_CONTEXT (t), args, /*complain=*/1,
5621 in_decl, /*entering_scope=*/1);
5622 DECL_CLASS_CONTEXT (r)
5623 = tsubst_aggr_type (DECL_CLASS_CONTEXT (t), args,
5624 /*complain=*/1, in_decl,
5625 /*entering_scope=*/1);
5626 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
5628 if (TREE_CODE (decl) == TYPE_DECL)
5630 tree new_type = tsubst (TREE_TYPE (t), args,
5631 /*complain=*/1, in_decl);
5632 TREE_TYPE (r) = new_type;
5633 CLASSTYPE_TI_TEMPLATE (new_type) = r;
5634 DECL_RESULT (r) = TYPE_MAIN_DECL (new_type);
5635 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
5639 tree new_decl = tsubst (decl, args, /*complain=*/1, in_decl);
5640 DECL_RESULT (r) = new_decl;
5641 DECL_TI_TEMPLATE (new_decl) = r;
5642 TREE_TYPE (r) = TREE_TYPE (new_decl);
5643 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
5646 SET_DECL_IMPLICIT_INSTANTIATION (r);
5647 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
5648 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
5650 /* The template parameters for this new template are all the
5651 template parameters for the old template, except the
5652 outermost level of parameters. */
5653 DECL_TEMPLATE_PARMS (r)
5654 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
5657 if (PRIMARY_TEMPLATE_P (t))
5658 DECL_PRIMARY_TEMPLATE (r) = r;
5660 /* We don't partially instantiate partial specializations. */
5661 if (TREE_CODE (decl) == TYPE_DECL)
5664 for (spec = DECL_TEMPLATE_SPECIALIZATIONS (t);
5666 spec = TREE_CHAIN (spec))
5668 /* It helps to consider example here. Consider:
5679 Now, for example, we are instantiating S<int>::f(U u).
5680 We want to make a template:
5685 It will have a specialization, for the case U = int*, of
5689 void S<int>::f<int*>(int*);
5691 This specialization will be an instantiation of
5692 the specialization given in the declaration of S, with
5693 argument list int*. */
5695 tree fn = TREE_VALUE (spec);
5699 if (!DECL_TEMPLATE_SPECIALIZATION (fn))
5700 /* Instantiations are on the same list, but they're of
5701 no concern to us. */
5704 if (TREE_CODE (fn) != TEMPLATE_DECL)
5705 /* A full specialization. There's no need to record
5709 spec_args = tsubst (DECL_TI_ARGS (fn), args,
5710 /*complain=*/1, in_decl);
5711 new_fn = tsubst (DECL_RESULT (most_general_template (fn)),
5712 spec_args, /*complain=*/1, in_decl);
5713 DECL_TI_TEMPLATE (new_fn) = fn;
5714 register_specialization (new_fn, r,
5715 innermost_args (spec_args));
5718 /* Record this partial instantiation. */
5719 register_specialization (r, t,
5720 DECL_TI_ARGS (DECL_RESULT (r)));
5728 tree argvec = NULL_TREE;
5735 /* Nobody should be tsubst'ing into non-template functions. */
5736 my_friendly_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE, 0);
5738 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
5742 /* Allocate template arguments on the momentary obstack,
5743 in case we don't need to keep them. */
5746 /* Calculate the most general template of which R is a
5747 specialization, and the complete set of arguments used to
5749 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
5751 = tsubst_template_arg_vector (DECL_TI_ARGS
5752 (DECL_TEMPLATE_RESULT (gen_tmpl)),
5753 args, /*complain=*/1);
5755 /* Check to see if we already have this specialization. */
5756 spec = retrieve_specialization (gen_tmpl, argvec);
5767 /* Here, we deal with the peculiar case:
5769 template <class T> struct S {
5770 template <class U> friend void f();
5772 template <class U> friend void f() {}
5774 template void f<double>();
5776 Here, the ARGS for the instantiation of will be {int,
5777 double}. But, we only need as many ARGS as there are
5778 levels of template parameters in CODE_PATTERN. We are
5779 careful not to get fooled into reducing the ARGS in
5782 template <class T> struct S { template <class U> void f(U); }
5783 template <class T> template <> void S<T>::f(int) {}
5785 which we can spot because the pattern will be a
5786 specialization in this case. */
5787 args_depth = TMPL_ARGS_DEPTH (args);
5789 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
5790 if (args_depth > parms_depth
5791 && !DECL_TEMPLATE_SPECIALIZATION (t))
5793 my_friendly_assert (DECL_FRIEND_P (t), 0);
5795 if (parms_depth > 1)
5799 args = make_temp_vec (parms_depth);
5800 for (i = 0; i < parms_depth; ++i)
5801 TREE_VEC_ELT (args, i) =
5802 TREE_VEC_ELT (args, i + (args_depth - parms_depth));
5805 args = TREE_VEC_ELT (args, args_depth - parms_depth);
5810 /* This special case arises when we have something like this:
5812 template <class T> struct S {
5813 friend void f<int>(int, double);
5816 Here, the DECL_TI_TEMPLATE for the friend declaration
5817 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5818 being called from tsubst_friend_function, and we want
5819 only to create a new decl (R) with appropriate types so
5820 that we can call determine_specialization. */
5821 my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t))
5823 || (TREE_CODE (DECL_TI_TEMPLATE (t))
5824 == IDENTIFIER_NODE), 0);
5825 gen_tmpl = NULL_TREE;
5828 if (DECL_CLASS_SCOPE_P (t))
5830 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
5834 ctx = tsubst_aggr_type (DECL_CLASS_CONTEXT (t), args,
5836 /*entering_scope=*/1);
5843 type = tsubst (type, args, /*complain=*/1, in_decl);
5845 /* We do NOT check for matching decls pushed separately at this
5846 point, as they may not represent instantiations of this
5847 template, and in any case are considered separate under the
5848 discrete model. Instead, see add_maybe_template. */
5852 DECL_USE_TEMPLATE (r) = 0;
5853 TREE_TYPE (r) = type;
5856 = tsubst_aggr_type (DECL_CONTEXT (t), args, /*complain=*/1, t,
5857 /*entering_scope=*/1);
5858 DECL_CLASS_CONTEXT (r) = ctx;
5860 if (member && IDENTIFIER_TYPENAME_P (DECL_NAME (r)))
5861 /* Type-conversion operator. Reconstruct the name, in
5862 case it's the name of one of the template's parameters. */
5863 DECL_NAME (r) = build_typename_overload (TREE_TYPE (type));
5865 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
5867 DECL_MAIN_VARIANT (r) = r;
5868 DECL_RESULT (r) = NULL_TREE;
5870 TREE_STATIC (r) = 0;
5871 TREE_PUBLIC (r) = TREE_PUBLIC (t);
5872 DECL_EXTERNAL (r) = 1;
5873 DECL_INTERFACE_KNOWN (r) = 0;
5874 DECL_DEFER_OUTPUT (r) = 0;
5875 TREE_CHAIN (r) = NULL_TREE;
5876 DECL_PENDING_INLINE_INFO (r) = 0;
5877 DECL_PENDING_INLINE_P (r) = 0;
5880 /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
5881 name. There's no need to do this in the special friend
5882 case mentioned above where GEN_TMPL is NULL. */
5885 DECL_TEMPLATE_INFO (r)
5886 = tree_cons (gen_tmpl, argvec, NULL_TREE);
5887 SET_DECL_IMPLICIT_INSTANTIATION (r);
5888 register_specialization (r, gen_tmpl, argvec);
5890 /* Set the mangled name for R. */
5891 if (DECL_DESTRUCTOR_P (t))
5892 DECL_ASSEMBLER_NAME (r) = build_destructor_name (ctx);
5895 /* Instantiations of template functions must be mangled
5896 specially, in order to conform to 14.5.5.1
5897 [temp.over.link]. */
5898 tree tmpl = DECL_TI_TEMPLATE (t);
5900 /* TMPL will be NULL if this is a specialization of a
5901 member function of a template class. */
5902 if (name_mangling_version < 1
5903 || tmpl == NULL_TREE
5904 || (member && !is_member_template (tmpl)
5905 && !DECL_TEMPLATE_INFO (tmpl)))
5906 set_mangled_name_for_decl (r);
5908 set_mangled_name_for_template_decl (r);
5912 make_decl_rtl (r, NULL_PTR, 1);
5914 /* Like grokfndecl. If we don't do this, pushdecl will
5915 mess up our TREE_CHAIN because it doesn't find a
5916 previous decl. Sigh. */
5918 && ! uses_template_parms (r)
5919 && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r))
5921 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r), r);
5923 /* We're not supposed to instantiate default arguments
5924 until they are called, for a template. But, for a
5927 template <class T> void f ()
5928 { extern void g(int i = T()); }
5930 we should do the substitution when the template is
5931 instantiated. We handle the member function case in
5932 instantiate_class_template since the default arguments
5933 might refer to other members of the class. */
5935 && !PRIMARY_TEMPLATE_P (gen_tmpl)
5936 && !uses_template_parms (argvec))
5937 tsubst_default_arguments (r);
5940 /* Copy the list of befriending classes. */
5941 for (friends = &DECL_BEFRIENDING_CLASSES (r);
5943 friends = &TREE_CHAIN (*friends))
5945 *friends = copy_node (*friends);
5946 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
5947 args, /*complain=*/1,
5951 if (DECL_CONSTRUCTOR_P (r))
5953 maybe_retrofit_in_chrg (r);
5954 grok_ctor_properties (ctx, r);
5956 else if (DECL_OVERLOADED_OPERATOR_P (r))
5957 grok_op_properties (r, DECL_VIRTUAL_P (r), DECL_FRIEND_P (r));
5964 TREE_TYPE (r) = type;
5965 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
5967 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
5968 DECL_INITIAL (r) = TREE_TYPE (r);
5970 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
5971 /*complain=*/1, in_decl);
5973 DECL_CONTEXT (r) = NULL_TREE;
5974 if (PROMOTE_PROTOTYPES
5975 && (TREE_CODE (type) == INTEGER_TYPE
5976 || TREE_CODE (type) == ENUMERAL_TYPE)
5977 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
5978 DECL_ARG_TYPE (r) = integer_type_node;
5980 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
5981 /*complain=*/1, TREE_CHAIN (t));
5989 TREE_TYPE (r) = type;
5990 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
5992 /* We don't have to set DECL_CONTEXT here; it is set by
5993 finish_member_declaration. */
5994 DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args,
5995 /*complain=*/1, in_decl);
5996 TREE_CHAIN (r) = NULL_TREE;
5997 if (TREE_CODE (type) == VOID_TYPE)
5998 cp_error_at ("instantiation of `%D' as type void", r);
6006 = tsubst_copy (DECL_INITIAL (t), args, /*complain=*/1, in_decl);
6007 TREE_CHAIN (r) = NULL_TREE;
6012 if (DECL_IMPLICIT_TYPEDEF_P (t))
6014 /* For an implicit typedef, we just want the implicit
6015 typedef for the tsubst'd type. We've already got the
6016 tsubst'd type, as TYPE, so we just need it's associated
6018 r = TYPE_NAME (type);
6021 else if (!DECL_LANG_SPECIFIC (t))
6023 /* For a template type parameter, we don't have to do
6024 anything special. */
6025 r= TYPE_NAME (type);
6039 /* Nobody should be tsubst'ing into non-template variables. */
6040 my_friendly_assert (DECL_LANG_SPECIFIC (t)
6041 && DECL_TEMPLATE_INFO (t) != NULL_TREE, 0);
6043 if (TYPE_P (DECL_CONTEXT (t)))
6044 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6046 in_decl, /*entering_scope=*/1);
6048 /* Subsequent calls to pushdecl will fill this in. */
6051 /* Check to see if we already have this specialization. */
6052 tmpl = DECL_TI_TEMPLATE (t);
6053 gen_tmpl = most_general_template (tmpl);
6054 argvec = tsubst (DECL_TI_ARGS (t), args, /*complain=*/1, in_decl);
6056 spec = retrieve_specialization (gen_tmpl, argvec);
6058 spec = retrieve_local_specialization (gen_tmpl,
6059 current_function_decl);
6067 /* This declaration is going to have to be around for a while,
6068 so me make sure it is on a saveable obstack. */
6069 push_obstacks_nochange ();
6070 saveable_allocation ();
6074 TREE_TYPE (r) = type;
6075 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
6076 DECL_CONTEXT (r) = ctx;
6078 /* Don't try to expand the initializer until someone tries to use
6079 this variable; otherwise we run into circular dependencies. */
6080 DECL_INITIAL (r) = NULL_TREE;
6084 DECL_CLASS_CONTEXT (r) = DECL_CONTEXT (r);
6086 /* Even if the original location is out of scope, the newly
6087 substituted one is not. */
6088 if (TREE_CODE (r) == VAR_DECL)
6089 DECL_DEAD_FOR_LOCAL (r) = 0;
6091 /* A static data member declaration is always marked external
6092 when it is declared in-class, even if an initializer is
6093 present. We mimic the non-template processing here. */
6095 DECL_EXTERNAL (r) = 1;
6097 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
6098 SET_DECL_IMPLICIT_INSTANTIATION (r);
6100 register_specialization (r, gen_tmpl, argvec);
6102 register_local_specialization (r, gen_tmpl,
6103 current_function_decl);
6105 TREE_CHAIN (r) = NULL_TREE;
6106 if (TREE_CODE (r) == VAR_DECL && TREE_CODE (type) == VOID_TYPE)
6107 cp_error_at ("instantiation of `%D' as type void", r);
6112 my_friendly_abort (0);
6115 /* Restore the file and line information. */
6116 lineno = saved_lineno;
6117 input_filename = saved_filename;
6122 /* Substitue into the ARG_TYPES of a function type. */
6125 tsubst_arg_types (arg_types, args, complain, in_decl)
6131 tree remaining_arg_types;
6134 if (!arg_types || arg_types == void_list_node)
6137 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
6138 args, complain, in_decl);
6139 if (remaining_arg_types == error_mark_node)
6140 return error_mark_node;
6142 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
6143 if (type == error_mark_node)
6144 return error_mark_node;
6146 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6147 top-level qualifiers as required. */
6148 type = TYPE_MAIN_VARIANT (type_decays_to (type));
6150 /* Note that we do not substitute into default arguments here. The
6151 standard mandates that they be instantiated only when needed,
6152 which is done in build_over_call. */
6153 return hash_tree_cons (TREE_PURPOSE (arg_types), type,
6154 remaining_arg_types);
6158 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6159 *not* handle the exception-specification for FNTYPE, because the
6160 initial substitution of explicitly provided template parameters
6161 during argument deduction forbids substitution into the
6162 exception-specification:
6166 All references in the function type of the function template to the
6167 corresponding template parameters are replaced by the specified tem-
6168 plate argument values. If a substitution in a template parameter or
6169 in the function type of the function template results in an invalid
6170 type, type deduction fails. [Note: The equivalent substitution in
6171 exception specifications is done only when the function is instanti-
6172 ated, at which point a program is ill-formed if the substitution
6173 results in an invalid type.] */
6176 tsubst_function_type (t, args, complain, in_decl)
6186 /* The TYPE_CONTEXT is not used for function/method types. */
6187 my_friendly_assert (TYPE_CONTEXT (t) == NULL_TREE, 0);
6189 /* Substitue the return type. */
6190 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6191 if (return_type == error_mark_node)
6192 return error_mark_node;
6194 /* Substitue the argument types. */
6195 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
6197 if (arg_types == error_mark_node)
6198 return error_mark_node;
6200 /* Construct a new type node and return it. */
6201 if (TREE_CODE (t) == FUNCTION_TYPE)
6202 fntype = build_function_type (return_type, arg_types);
6205 tree r = TREE_TYPE (TREE_VALUE (arg_types));
6206 if (! IS_AGGR_TYPE (r))
6210 Type deduction may fail for any of the following
6213 -- Attempting to create "pointer to member of T" when T
6214 is not a class type. */
6216 cp_error ("creating pointer to member function of non-class type `%T'",
6218 return error_mark_node;
6221 fntype = build_cplus_method_type (r, return_type, TREE_CHAIN
6224 fntype = build_qualified_type (fntype, TYPE_QUALS (t));
6225 fntype = build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
6230 /* Substitute into the PARMS of a call-declarator. */
6233 tsubst_call_declarator_parms (parms, args, complain, in_decl)
6243 if (!parms || parms == void_list_node)
6246 new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms),
6247 args, complain, in_decl);
6249 /* Figure out the type of this parameter. */
6250 type = tsubst (TREE_VALUE (parms), args, complain, in_decl);
6252 /* Figure out the default argument as well. Note that we use
6253 tsubst_expr since the default argument is really an expression. */
6254 defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl);
6256 /* Chain this parameter on to the front of those we have already
6257 processed. We don't use hash_tree_cons because that function
6258 doesn't check TREE_PARMLIST. */
6259 new_parms = tree_cons (defarg, type, new_parms);
6261 /* And note that these are parameters. */
6262 TREE_PARMLIST (new_parms) = 1;
6267 /* Take the tree structure T and replace template parameters used
6268 therein with the argument vector ARGS. IN_DECL is an associated
6269 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6270 An appropriate error message is issued only if COMPLAIN is
6271 non-zero. Note that we must be relatively non-tolerant of
6272 extensions here, in order to preserve conformance; if we allow
6273 substitutions that should not be allowed, we may allow argument
6274 deductions that should not succeed, and therefore report ambiguous
6275 overload situations where there are none. In theory, we could
6276 allow the substitution, but indicate that it should have failed,
6277 and allow our caller to make sure that the right thing happens, but
6278 we don't try to do this yet.
6280 This function is used for dealing with types, decls and the like;
6281 for expressions, use tsubst_expr or tsubst_copy. */
6284 tsubst (t, args, complain, in_decl)
6291 if (t == NULL_TREE || t == error_mark_node
6292 || t == integer_type_node
6293 || t == void_type_node
6294 || t == char_type_node
6295 || TREE_CODE (t) == NAMESPACE_DECL)
6298 if (TREE_CODE (t) == IDENTIFIER_NODE)
6299 type = IDENTIFIER_TYPE_VALUE (t);
6301 type = TREE_TYPE (t);
6302 if (type == unknown_type_node)
6303 my_friendly_abort (42);
6305 if (type && TREE_CODE (t) != FUNCTION_DECL
6306 && TREE_CODE (t) != TYPENAME_TYPE
6307 && TREE_CODE (t) != TEMPLATE_DECL
6308 && TREE_CODE (t) != IDENTIFIER_NODE
6309 && TREE_CODE (t) != FUNCTION_TYPE
6310 && TREE_CODE (t) != METHOD_TYPE)
6311 type = tsubst (type, args, complain, in_decl);
6312 if (type == error_mark_node)
6313 return error_mark_node;
6315 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'd')
6316 return tsubst_decl (t, args, type, in_decl);
6318 switch (TREE_CODE (t))
6323 return tsubst_aggr_type (t, args, complain, in_decl,
6324 /*entering_scope=*/0);
6327 case IDENTIFIER_NODE:
6339 if (t == integer_type_node)
6342 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
6343 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
6347 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
6349 max = tsubst_expr (omax, args, complain, in_decl);
6350 if (max == error_mark_node)
6351 return error_mark_node;
6353 /* See if we can reduce this expression to something simpler. */
6354 max = maybe_fold_nontype_arg (max);
6355 if (!processing_template_decl && TREE_READONLY_DECL_P (max))
6356 max = decl_constant_value (max);
6358 if (processing_template_decl
6359 /* When providing explicit arguments to a template
6360 function, but leaving some arguments for subsequent
6361 deduction, MAX may be template-dependent even if we're
6362 not PROCESSING_TEMPLATE_DECL. */
6363 || TREE_CODE (max) != INTEGER_CST)
6365 tree itype = make_node (INTEGER_TYPE);
6366 TYPE_MIN_VALUE (itype) = size_zero_node;
6367 TYPE_MAX_VALUE (itype) = build_min (MINUS_EXPR, sizetype, max,
6372 if (integer_zerop (omax))
6374 /* Still allow an explicit array of size zero. */
6376 pedwarn ("creating array with size zero");
6378 else if (integer_zerop (max) || INT_CST_LT (max, integer_zero_node))
6382 Type deduction may fail for any of the following
6385 Attempting to create an array with a size that is
6386 zero or negative. */
6388 cp_error ("creating array with size `%E'", max);
6390 return error_mark_node;
6393 max = fold (build_binary_op (MINUS_EXPR, max, integer_one_node));
6394 return build_index_type (max);
6397 case TEMPLATE_TYPE_PARM:
6398 case TEMPLATE_TEMPLATE_PARM:
6399 case TEMPLATE_PARM_INDEX:
6407 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
6408 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
6410 idx = TEMPLATE_TYPE_IDX (t);
6411 level = TEMPLATE_TYPE_LEVEL (t);
6415 idx = TEMPLATE_PARM_IDX (t);
6416 level = TEMPLATE_PARM_LEVEL (t);
6419 if (TREE_VEC_LENGTH (args) > 0)
6421 tree arg = NULL_TREE;
6423 levels = TMPL_ARGS_DEPTH (args);
6424 if (level <= levels)
6425 arg = TMPL_ARG (args, level, idx);
6427 if (arg == error_mark_node)
6428 return error_mark_node;
6429 else if (arg != NULL_TREE)
6431 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
6433 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg))
6435 return cp_build_qualified_type_real
6436 (arg, CP_TYPE_QUALS (arg) | CP_TYPE_QUALS (t),
6439 else if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
6441 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t))
6443 /* We are processing a type constructed from
6444 a template template parameter */
6445 tree argvec = tsubst (TYPE_TI_ARGS (t),
6446 args, complain, in_decl);
6447 if (argvec == error_mark_node)
6448 return error_mark_node;
6450 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6451 we are resolving nested-types in the signature of
6452 a member function templates.
6453 Otherwise ARG is a TEMPLATE_DECL and is the real
6454 template to be instantiated. */
6455 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
6456 arg = TYPE_NAME (arg);
6458 r = lookup_template_class (DECL_NAME (arg),
6461 /*entering_scope=*/0);
6462 return cp_build_qualified_type_real (r,
6467 /* We are processing a template argument list. */
6475 my_friendly_abort (981018);
6478 /* This can happen during the attempted tsubst'ing in
6479 unify. This means that we don't yet have any information
6480 about the template parameter in question. */
6483 /* If we get here, we must have been looking at a parm for a
6484 more deeply nested template. Make a new version of this
6485 template parameter, but with a lower level. */
6486 switch (TREE_CODE (t))
6488 case TEMPLATE_TYPE_PARM:
6489 case TEMPLATE_TEMPLATE_PARM:
6491 TEMPLATE_TYPE_PARM_INDEX (r)
6492 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
6494 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
6495 TYPE_MAIN_VARIANT (r) = r;
6496 TYPE_POINTER_TO (r) = NULL_TREE;
6497 TYPE_REFERENCE_TO (r) = NULL_TREE;
6499 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
6500 && TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t))
6502 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
6504 if (argvec == error_mark_node)
6505 return error_mark_node;
6507 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
6508 = tree_cons (TYPE_NAME (t), argvec, NULL_TREE);
6512 case TEMPLATE_PARM_INDEX:
6513 r = reduce_template_parm_level (t, type, levels);
6517 my_friendly_abort (0);
6525 tree purpose, value, chain, result;
6527 if (t == void_list_node)
6530 purpose = TREE_PURPOSE (t);
6533 purpose = tsubst (purpose, args, complain, in_decl);
6534 if (purpose == error_mark_node)
6535 return error_mark_node;
6537 value = TREE_VALUE (t);
6540 value = tsubst (value, args, complain, in_decl);
6541 if (value == error_mark_node)
6542 return error_mark_node;
6544 chain = TREE_CHAIN (t);
6545 if (chain && chain != void_type_node)
6547 chain = tsubst (chain, args, complain, in_decl);
6548 if (chain == error_mark_node)
6549 return error_mark_node;
6551 if (purpose == TREE_PURPOSE (t)
6552 && value == TREE_VALUE (t)
6553 && chain == TREE_CHAIN (t))
6555 result = hash_tree_cons (purpose, value, chain);
6556 TREE_PARMLIST (result) = TREE_PARMLIST (t);
6560 if (type != NULL_TREE)
6562 /* A binfo node. We always need to make a copy, of the node
6563 itself and of its BINFO_BASETYPES. */
6567 /* Make sure type isn't a typedef copy. */
6568 type = BINFO_TYPE (TYPE_BINFO (type));
6570 TREE_TYPE (t) = complete_type (type);
6571 if (IS_AGGR_TYPE (type))
6573 BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type);
6574 BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type);
6575 if (TYPE_BINFO_BASETYPES (type) != NULL_TREE)
6576 BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type));
6581 /* Otherwise, a vector of template arguments. */
6582 return tsubst_template_arg_vector (t, args, complain);
6585 case REFERENCE_TYPE:
6587 enum tree_code code;
6589 if (type == TREE_TYPE (t))
6592 code = TREE_CODE (t);
6597 Type deduction may fail for any of the following
6600 -- Attempting to create a pointer to reference type.
6601 -- Attempting to create a reference to a reference type or
6602 a reference to void. */
6603 if (TREE_CODE (type) == REFERENCE_TYPE
6604 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
6606 static int last_line = 0;
6607 static char* last_file = 0;
6609 /* We keep track of the last time we issued this error
6610 message to avoid spewing a ton of messages during a
6611 single bad template instantiation. */
6612 if (complain && (last_line != lineno ||
6613 last_file != input_filename))
6615 if (TREE_CODE (type) == VOID_TYPE)
6616 cp_error ("forming reference to void");
6618 cp_error ("forming %s to reference type `%T'",
6619 (code == POINTER_TYPE) ? "pointer" : "reference",
6622 last_file = input_filename;
6625 return error_mark_node;
6627 else if (code == POINTER_TYPE)
6628 r = build_pointer_type (type);
6630 r = build_reference_type (type);
6631 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6633 /* Will this ever be needed for TYPE_..._TO values? */
6639 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
6640 if (r == error_mark_node || !IS_AGGR_TYPE (r))
6644 Type deduction may fail for any of the following
6647 -- Attempting to create "pointer to member of T" when T
6648 is not a class type. */
6650 cp_error ("creating pointer to member of non-class type `%T'",
6652 return error_mark_node;
6654 return build_offset_type (r, type);
6662 fntype = tsubst_function_type (t, args, complain, in_decl);
6663 if (fntype == error_mark_node)
6664 return error_mark_node;
6666 /* Substitue the exception specification. */
6667 raises = TYPE_RAISES_EXCEPTIONS (t);
6670 tree list = NULL_TREE;
6672 if (! TREE_VALUE (raises))
6675 for (; raises != NULL_TREE; raises = TREE_CHAIN (raises))
6677 tree spec = TREE_VALUE (raises);
6679 spec = tsubst (spec, args, complain, in_decl);
6680 if (spec == error_mark_node)
6682 list = add_exception_specifier (list, spec, complain);
6684 fntype = build_exception_variant (fntype, list);
6690 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
6691 if (domain == error_mark_node)
6692 return error_mark_node;
6694 /* As an optimization, we avoid regenerating the array type if
6695 it will obviously be the same as T. */
6696 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
6699 /* These checks should match the ones in grokdeclarator.
6703 The deduction may fail for any of the following reasons:
6705 -- Attempting to create an array with an element type that
6706 is void, a function type, or a reference type. */
6707 if (TREE_CODE (type) == VOID_TYPE
6708 || TREE_CODE (type) == FUNCTION_TYPE
6709 || TREE_CODE (type) == REFERENCE_TYPE)
6712 cp_error ("creating array of `%T'", type);
6713 return error_mark_node;
6716 r = build_cplus_array_type (type, domain);
6723 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
6725 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain,
6728 if (e1 == error_mark_node || e2 == error_mark_node)
6729 return error_mark_node;
6731 return fold (build (TREE_CODE (t), TREE_TYPE (t), e1, e2));
6737 tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
6739 if (e == error_mark_node)
6740 return error_mark_node;
6742 return fold (build (TREE_CODE (t), TREE_TYPE (t), e));
6747 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
6748 in_decl, /*entering_scope=*/1);
6749 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
6752 if (ctx == error_mark_node || f == error_mark_node)
6753 return error_mark_node;
6755 if (!IS_AGGR_TYPE (ctx))
6758 cp_error ("`%T' is not a class, struct, or union type",
6760 return error_mark_node;
6762 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
6764 /* Normally, make_typename_type does not require that the CTX
6765 have complete type in order to allow things like:
6767 template <class T> struct S { typename S<T>::X Y; };
6769 But, such constructs have already been resolved by this
6770 point, so here CTX really should have complete type, unless
6771 it's a partial instantiation. */
6772 ctx = complete_type (ctx);
6773 if (!TYPE_SIZE (ctx))
6776 incomplete_type_error (NULL_TREE, ctx);
6777 return error_mark_node;
6781 f = make_typename_type (ctx, f);
6782 if (f == error_mark_node)
6784 return cp_build_qualified_type_real (f,
6786 | CP_TYPE_QUALS (t),
6792 tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
6794 if (e == error_mark_node)
6795 return error_mark_node;
6796 return make_pointer_declarator (type, e);
6801 tree e = tsubst (TREE_OPERAND (t, 0), args, complain,
6803 if (e == error_mark_node)
6804 return error_mark_node;
6805 return make_reference_declarator (type, e);
6810 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
6812 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain,
6814 if (e1 == error_mark_node || e2 == error_mark_node)
6815 return error_mark_node;
6817 return build_parse_node (ARRAY_REF, e1, e2, tsubst_expr);
6822 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
6824 tree e2 = (tsubst_call_declarator_parms
6825 (CALL_DECLARATOR_PARMS (t), args, complain, in_decl));
6826 tree e3 = tsubst (CALL_DECLARATOR_EXCEPTION_SPEC (t), args,
6829 if (e1 == error_mark_node || e2 == error_mark_node
6830 || e3 == error_mark_node)
6831 return error_mark_node;
6833 return make_call_declarator (e1, e2, CALL_DECLARATOR_QUALS (t), e3);
6838 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain,
6840 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
6841 if (e1 == error_mark_node || e2 == error_mark_node)
6842 return error_mark_node;
6844 return build_parse_node (TREE_CODE (t), e1, e2);
6849 tree e1 = tsubst_expr (TYPE_FIELDS (t), args, complain,
6851 if (e1 == error_mark_node)
6852 return error_mark_node;
6854 return TREE_TYPE (e1);
6858 sorry ("use of `%s' in template",
6859 tree_code_name [(int) TREE_CODE (t)]);
6860 return error_mark_node;
6864 /* Like tsubst, but deals with expressions. This function just replaces
6865 template parms; to finish processing the resultant expression, use
6869 tsubst_copy (t, args, complain, in_decl)
6874 enum tree_code code;
6877 if (t == NULL_TREE || t == error_mark_node)
6880 code = TREE_CODE (t);
6885 return do_identifier (DECL_NAME (t), 0, NULL_TREE);
6892 if (!DECL_CONTEXT (t))
6893 /* This is a global enumeration constant. */
6896 /* Unfortunately, we cannot just call lookup_name here.
6899 template <int I> int f() {
6901 struct S { void g() { E e = a; } };
6904 When we instantiate f<7>::S::g(), say, lookup_name is not
6905 clever enough to find f<7>::a. */
6907 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
6908 /*entering_scope=*/0);
6910 for (v = TYPE_VALUES (enum_type);
6913 if (TREE_PURPOSE (v) == DECL_NAME (t))
6914 return TREE_VALUE (v);
6916 /* We didn't find the name. That should never happen; if
6917 name-lookup found it during preliminary parsing, we
6918 should find it again here during instantiation. */
6919 my_friendly_abort (0);
6924 if (DECL_CONTEXT (t))
6928 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
6929 /*entering_scope=*/1);
6930 if (ctx != DECL_CONTEXT (t))
6931 return lookup_field (ctx, DECL_NAME (t), 0, 0);
6937 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
6938 t = tsubst (t, args, complain, in_decl);
6943 if (is_member_template (t))
6944 return tsubst (t, args, complain, in_decl);
6950 /* We must tsbust into a LOOKUP_EXPR in case the names to
6951 which it refers is a conversion operator; in that case the
6952 name will change. We avoid making unnecessary copies,
6955 tree id = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
6957 if (id != TREE_OPERAND (t, 0))
6959 r = build_nt (LOOKUP_EXPR, id);
6960 LOOKUP_EXPR_GLOBAL (r) = LOOKUP_EXPR_GLOBAL (t);
6968 case REINTERPRET_CAST_EXPR:
6969 case CONST_CAST_EXPR:
6970 case STATIC_CAST_EXPR:
6971 case DYNAMIC_CAST_EXPR:
6974 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
6975 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
6978 case PREDECREMENT_EXPR:
6979 case PREINCREMENT_EXPR:
6980 case POSTDECREMENT_EXPR:
6981 case POSTINCREMENT_EXPR:
6983 case TRUTH_NOT_EXPR:
6986 case CONVERT_EXPR: /* Unary + */
6993 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
6994 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
6999 case TRUNC_DIV_EXPR:
7001 case FLOOR_DIV_EXPR:
7002 case ROUND_DIV_EXPR:
7003 case EXACT_DIV_EXPR:
7005 case BIT_ANDTC_EXPR:
7008 case TRUNC_MOD_EXPR:
7009 case FLOOR_MOD_EXPR:
7010 case TRUTH_ANDIF_EXPR:
7011 case TRUTH_ORIF_EXPR:
7012 case TRUTH_AND_EXPR:
7033 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7034 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7038 tree fn = TREE_OPERAND (t, 0);
7039 if (is_overloaded_fn (fn))
7040 fn = tsubst_copy (get_first_fn (fn), args, complain, in_decl);
7042 /* Sometimes FN is a LOOKUP_EXPR. */
7043 fn = tsubst_copy (fn, args, complain, in_decl);
7045 (code, fn, tsubst_copy (TREE_OPERAND (t, 1), args, complain,
7050 case METHOD_CALL_EXPR:
7052 tree name = TREE_OPERAND (t, 0);
7053 if (TREE_CODE (name) == BIT_NOT_EXPR)
7055 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7057 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7059 else if (TREE_CODE (name) == SCOPE_REF
7060 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
7062 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
7064 name = TREE_OPERAND (name, 1);
7065 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7067 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7068 name = build_nt (SCOPE_REF, base, name);
7071 name = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
7073 (code, name, tsubst_copy (TREE_OPERAND (t, 1), args,
7075 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl),
7080 /* This processing should really occur in tsubst_expr, However,
7081 tsubst_expr does not recurse into expressions, since it
7082 assumes that there aren't any statements inside them.
7083 Instead, it simply calls build_expr_from_tree. So, we need
7084 to expand the STMT_EXPR here. */
7085 if (!processing_template_decl)
7087 tree rtl_expr = begin_stmt_expr ();
7088 tree block = tsubst_expr (STMT_EXPR_STMT (t), args,
7090 return finish_stmt_expr (rtl_expr, block);
7097 case PSEUDO_DTOR_EXPR:
7100 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7101 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7102 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7109 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7110 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7111 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7112 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
7119 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7120 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7121 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
7122 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
7126 case TEMPLATE_ID_EXPR:
7128 /* Substituted template arguments */
7129 tree targs = tsubst_copy (TREE_OPERAND (t, 1), args, complain,
7132 if (targs && TREE_CODE (targs) == TREE_LIST)
7135 for (chain = targs; chain; chain = TREE_CHAIN (chain))
7136 TREE_VALUE (chain) = maybe_fold_nontype_arg (TREE_VALUE (chain));
7141 for (i = 0; i < TREE_VEC_LENGTH (targs); ++i)
7142 TREE_VEC_ELT (targs, i)
7143 = maybe_fold_nontype_arg (TREE_VEC_ELT (targs, i));
7146 return lookup_template_function
7147 (tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl), targs);
7152 tree purpose, value, chain;
7154 if (t == void_list_node)
7157 purpose = TREE_PURPOSE (t);
7159 purpose = tsubst_copy (purpose, args, complain, in_decl);
7160 value = TREE_VALUE (t);
7162 value = tsubst_copy (value, args, complain, in_decl);
7163 chain = TREE_CHAIN (t);
7164 if (chain && chain != void_type_node)
7165 chain = tsubst_copy (chain, args, complain, in_decl);
7166 if (purpose == TREE_PURPOSE (t)
7167 && value == TREE_VALUE (t)
7168 && chain == TREE_CHAIN (t))
7170 return tree_cons (purpose, value, chain);
7177 case TEMPLATE_TYPE_PARM:
7178 case TEMPLATE_TEMPLATE_PARM:
7179 case TEMPLATE_PARM_INDEX:
7181 case REFERENCE_TYPE:
7188 return tsubst (t, args, complain, in_decl);
7190 case IDENTIFIER_NODE:
7191 if (IDENTIFIER_TYPENAME_P (t)
7192 /* Make sure it's not just a variable named `__opr', for instance,
7193 which can occur in some existing code. */
7195 return build_typename_overload
7196 (tsubst (TREE_TYPE (t), args, complain, in_decl));
7203 (CONSTRUCTOR, tsubst (TREE_TYPE (t), args, complain, in_decl),
7204 NULL_TREE, tsubst_copy (CONSTRUCTOR_ELTS (t), args,
7205 complain, in_decl));
7206 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
7211 return build_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
7213 tsubst (TREE_TYPE (t), args, complain, in_decl));
7220 /* Like tsubst_copy, but also does semantic processing. */
7223 tsubst_expr (t, args, complain, in_decl)
7230 if (t == NULL_TREE || t == error_mark_node)
7233 if (processing_template_decl)
7234 return tsubst_copy (t, args, complain, in_decl);
7236 switch (TREE_CODE (t))
7240 finish_named_return_value
7241 (TREE_OPERAND (t, 0),
7242 tsubst_expr (TREE_OPERAND (t, 1), args, /*complain=*/1, in_decl));
7243 tsubst_expr (TREE_CHAIN (t), args, complain, in_decl);
7246 case CTOR_INITIALIZER:
7248 current_member_init_list
7249 = tsubst_expr_values (TREE_OPERAND (t, 0), args);
7250 current_base_init_list
7251 = tsubst_expr_values (TREE_OPERAND (t, 1), args);
7253 tsubst_expr (TREE_CHAIN (t), args, complain, in_decl);
7258 finish_return_stmt (tsubst_expr (RETURN_EXPR (t),
7259 args, complain, in_decl));
7264 finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t),
7265 args, complain, in_decl));
7270 int i = suspend_momentary ();
7275 decl = DECL_STMT_DECL (t);
7276 if (TREE_CODE (decl) == LABEL_DECL)
7277 finish_label_decl (DECL_NAME (decl));
7280 init = DECL_INITIAL (decl);
7281 decl = tsubst (decl, args, complain, in_decl);
7282 init = tsubst_expr (init, args, complain, in_decl);
7284 DECL_INITIAL (decl) = error_mark_node;
7285 /* By marking the declaration as instantiated, we avoid
7286 trying to instantiate it. Since instantiate_decl can't
7287 handle local variables, and since we've already done
7288 all that needs to be done, that's the right thing to
7290 if (TREE_CODE (decl) == VAR_DECL)
7291 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
7292 maybe_push_decl (decl);
7293 cp_finish_decl (decl, init, NULL_TREE, 0, 0);
7295 resume_momentary (i);
7304 stmt = begin_for_stmt ();
7305 for (tmp = FOR_INIT_STMT (t); tmp; tmp = TREE_CHAIN (tmp))
7306 tsubst_expr (tmp, args, complain, in_decl);
7307 finish_for_init_stmt (stmt);
7308 finish_for_cond (tsubst_expr (FOR_COND (t), args,
7311 tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
7312 finish_for_expr (tmp, stmt);
7313 tsubst_expr (FOR_BODY (t), args, complain, in_decl);
7314 finish_for_stmt (tmp, stmt);
7321 stmt = begin_while_stmt ();
7322 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t),
7323 args, complain, in_decl),
7325 tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
7326 finish_while_stmt (stmt);
7333 stmt = begin_do_stmt ();
7334 tsubst_expr (DO_BODY (t), args, complain, in_decl);
7335 finish_do_body (stmt);
7336 finish_do_stmt (tsubst_expr (DO_COND (t), args,
7347 stmt = begin_if_stmt ();
7348 finish_if_stmt_cond (tsubst_expr (IF_COND (t),
7349 args, complain, in_decl),
7352 if (tmp = THEN_CLAUSE (t), tmp)
7354 tsubst_expr (tmp, args, complain, in_decl);
7355 finish_then_clause (stmt);
7358 if (tmp = ELSE_CLAUSE (t), tmp)
7360 begin_else_clause ();
7361 tsubst_expr (tmp, args, complain, in_decl);
7362 finish_else_clause (stmt);
7374 stmt = begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t));
7375 for (substmt = COMPOUND_BODY (t);
7376 substmt != NULL_TREE;
7377 substmt = TREE_CHAIN (substmt))
7378 tsubst_expr (substmt, args, complain, in_decl);
7379 return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t), stmt);
7385 finish_break_stmt ();
7390 finish_continue_stmt ();
7398 stmt = begin_switch_stmt ();
7399 val = tsubst_expr (SWITCH_COND (t), args, complain, in_decl);
7400 finish_switch_cond (val, stmt);
7401 tsubst_expr (SWITCH_BODY (t), args, complain, in_decl);
7402 finish_switch_stmt (val, stmt);
7408 finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl),
7409 tsubst_expr (CASE_HIGH (t), args, complain, in_decl));
7413 lineno = STMT_LINENO (t);
7414 finish_label_stmt (DECL_NAME (LABEL_STMT_LABEL (t)));
7419 t = GOTO_DESTINATION (t);
7420 if (TREE_CODE (t) != LABEL_DECL)
7421 /* Computed goto's must be tsubst'd into. On the other hand,
7422 non-computed gotos must not be; the identifier in question
7423 will have no binding. */
7424 t = tsubst_expr (t, args, complain, in_decl);
7427 finish_goto_stmt (t);
7432 finish_asm_stmt (ASM_CV_QUAL (t),
7433 tsubst_expr (ASM_STRING (t), args, complain, in_decl),
7434 tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl),
7435 tsubst_expr (ASM_INPUTS (t), args, complain, in_decl),
7436 tsubst_expr (ASM_CLOBBERS (t), args, complain,
7444 stmt = begin_try_block ();
7445 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
7446 finish_cleanup_try_block (stmt);
7447 finish_cleanup (tsubst_expr (TRY_HANDLERS (t), args,
7455 if (FN_TRY_BLOCK_P (t))
7456 stmt = begin_function_try_block ();
7458 stmt = begin_try_block ();
7460 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
7462 if (FN_TRY_BLOCK_P (t))
7463 finish_function_try_block (stmt);
7465 finish_try_block (stmt);
7467 handler = TRY_HANDLERS (t);
7468 for (; handler; handler = TREE_CHAIN (handler))
7469 tsubst_expr (handler, args, complain, in_decl);
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;