1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 93-97, 1998, 1999 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Known bugs or deficiencies include:
25 all methods must be provided in header files; can't use a source
26 file that contains only the method templates and "just win". */
46 /* The type of functions taking a tree, and some additional data, and
48 typedef int (*tree_fn_t
) PROTO((tree
, void*));
50 extern struct obstack permanent_obstack
;
53 extern char *input_filename
;
55 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
56 instantiations have been deferred, either because their definitions
57 were not yet available, or because we were putting off doing the
58 work. The TREE_PURPOSE of each entry is a SRCLOC indicating where
59 the instantiate request occurred; the TREE_VALUE is a either a DECL
60 (for a function or static data member), or a TYPE (for a class)
61 indicating what we are hoping to instantiate. */
62 static tree pending_templates
;
63 static tree
*template_tail
= &pending_templates
;
65 static tree maybe_templates
;
66 static tree
*maybe_template_tail
= &maybe_templates
;
68 int processing_template_parmlist
;
69 static int template_header_count
;
71 static tree saved_trees
;
72 static varray_type inline_parm_levels
;
73 static size_t inline_parm_levels_used
;
75 #define obstack_chunk_alloc xmalloc
76 #define obstack_chunk_free free
78 #define UNIFY_ALLOW_NONE 0
79 #define UNIFY_ALLOW_MORE_CV_QUAL 1
80 #define UNIFY_ALLOW_LESS_CV_QUAL 2
81 #define UNIFY_ALLOW_DERIVED 4
82 #define UNIFY_ALLOW_INTEGER 8
84 #define GTB_VIA_VIRTUAL 1 /* The base class we are examining is
85 virtual, or a base class of a virtual
87 #define GTB_IGNORE_TYPE 2 /* We don't need to try to unify the current
88 type with the desired type. */
90 static int resolve_overloaded_unification
PROTO((tree
, tree
, tree
, tree
,
91 unification_kind_t
, int));
92 static int try_one_overload
PROTO((tree
, tree
, tree
, tree
, tree
,
93 unification_kind_t
, int));
94 static int unify
PROTO((tree
, tree
, tree
, tree
, int));
95 static void add_pending_template
PROTO((tree
));
96 static int push_tinst_level
PROTO((tree
));
97 static tree classtype_mangled_name
PROTO((tree
));
98 static char *mangle_class_name_for_template
PROTO((char *, tree
, tree
));
99 static tree tsubst_expr_values
PROTO((tree
, tree
));
100 static int list_eq
PROTO((tree
, tree
));
101 static tree get_class_bindings
PROTO((tree
, tree
, tree
));
102 static tree coerce_template_parms
PROTO((tree
, tree
, tree
, int, int));
103 static void tsubst_enum
PROTO((tree
, tree
, tree
));
104 static tree add_to_template_args
PROTO((tree
, tree
));
105 static tree add_outermost_template_args
PROTO((tree
, tree
));
106 static void maybe_adjust_types_for_deduction
PROTO((unification_kind_t
, tree
*,
108 static int type_unification_real
PROTO((tree
, tree
, tree
, tree
,
109 int, unification_kind_t
, int));
110 static void note_template_header
PROTO((int));
111 static tree maybe_fold_nontype_arg
PROTO((tree
));
112 static tree convert_nontype_argument
PROTO((tree
, tree
));
113 static tree convert_template_argument
PROTO ((tree
, tree
, tree
, int,
115 static tree get_bindings_overload
PROTO((tree
, tree
, tree
));
116 static int for_each_template_parm
PROTO((tree
, tree_fn_t
, void*));
117 static tree build_template_parm_index
PROTO((int, int, int, tree
, tree
));
118 static int inline_needs_template_parms
PROTO((tree
));
119 static void push_inline_template_parms_recursive
PROTO((tree
, int));
120 static tree retrieve_specialization
PROTO((tree
, tree
));
121 static tree retrieve_local_specialization
PROTO((tree
, tree
));
122 static tree register_specialization
PROTO((tree
, tree
, tree
));
123 static tree register_local_specialization
PROTO((tree
, tree
, tree
));
124 static int unregister_specialization
PROTO((tree
, tree
));
125 static tree reduce_template_parm_level
PROTO((tree
, tree
, int));
126 static tree build_template_decl
PROTO((tree
, tree
));
127 static int mark_template_parm
PROTO((tree
, void *));
128 static tree tsubst_friend_function
PROTO((tree
, tree
));
129 static tree tsubst_friend_class
PROTO((tree
, tree
));
130 static tree get_bindings_real
PROTO((tree
, tree
, tree
, int));
131 static int template_decl_level
PROTO((tree
));
132 static tree maybe_get_template_decl_from_type_decl
PROTO((tree
));
133 static int check_cv_quals_for_unify
PROTO((int, tree
, tree
));
134 static tree tsubst_template_arg_vector
PROTO((tree
, tree
, int));
135 static tree tsubst_template_parms
PROTO((tree
, tree
, int));
136 static void regenerate_decl_from_template
PROTO((tree
, tree
));
137 static tree most_specialized
PROTO((tree
, tree
, tree
));
138 static tree most_specialized_class
PROTO((tree
, tree
));
139 static void set_mangled_name_for_template_decl
PROTO((tree
));
140 static int template_class_depth_real
PROTO((tree
, int));
141 static tree tsubst_aggr_type
PROTO((tree
, tree
, int, tree
, int));
142 static tree tsubst_decl
PROTO((tree
, tree
, tree
, tree
));
143 static tree tsubst_arg_types
PROTO((tree
, tree
, int, tree
));
144 static tree tsubst_function_type
PROTO((tree
, tree
, int, tree
));
145 static void check_specialization_scope
PROTO((void));
146 static tree process_partial_specialization
PROTO((tree
));
147 static void set_current_access_from_decl
PROTO((tree
));
148 static void check_default_tmpl_args
PROTO((tree
, tree
, int, int));
149 static tree tsubst_call_declarator_parms
PROTO((tree
, tree
, int, tree
));
150 static tree get_template_base_recursive
PROTO((tree
, tree
,
151 tree
, tree
, tree
, int));
152 static tree get_template_base
PROTO((tree
, tree
, tree
, tree
));
153 static tree try_class_unification
PROTO((tree
, tree
, tree
, tree
));
154 static int coerce_template_template_parms
PROTO((tree
, tree
, int,
156 static tree determine_specialization
PROTO((tree
, tree
, tree
*, int));
157 static int template_args_equal
PROTO((tree
, tree
));
158 static void print_template_context
PROTO((int));
159 static void tsubst_default_arguments
PROTO((tree
));
160 static tree for_each_template_parm_r
PROTO((tree
*, int *, void *));
162 /* Called once to initialize pt.c. */
167 ggc_add_tree_root (&pending_templates
, 1);
168 ggc_add_tree_root (&maybe_templates
, 1);
169 ggc_add_tree_root (&saved_trees
, 1);
172 /* Do any processing required when DECL (a member template declaration
173 using TEMPLATE_PARAMETERS as its innermost parameter list) is
174 finished. Returns the TEMPLATE_DECL corresponding to DECL, unless
175 it is a specialization, in which case the DECL itself is returned. */
178 finish_member_template_decl (decl
)
181 if (decl
== NULL_TREE
|| decl
== void_type_node
)
183 else if (decl
== error_mark_node
)
184 /* By returning NULL_TREE, the parser will just ignore this
185 declaration. We have already issued the error. */
187 else if (TREE_CODE (decl
) == TREE_LIST
)
189 /* Assume that the class is the only declspec. */
190 decl
= TREE_VALUE (decl
);
191 if (IS_AGGR_TYPE (decl
) && CLASSTYPE_TEMPLATE_INFO (decl
)
192 && ! CLASSTYPE_TEMPLATE_SPECIALIZATION (decl
))
194 tree tmpl
= CLASSTYPE_TI_TEMPLATE (decl
);
195 check_member_template (tmpl
);
200 else if (DECL_TEMPLATE_INFO (decl
))
202 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
204 check_member_template (DECL_TI_TEMPLATE (decl
));
205 return DECL_TI_TEMPLATE (decl
);
211 cp_error ("invalid member template declaration `%D'", decl
);
213 return error_mark_node
;
216 /* Returns the template nesting level of the indicated class TYPE.
226 A<T>::B<U> has depth two, while A<T> has depth one.
227 Both A<T>::B<int> and A<int>::B<U> have depth one, if
228 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
231 This function is guaranteed to return 0 if passed NULL_TREE so
232 that, for example, `template_class_depth (current_class_type)' is
236 template_class_depth_real (type
, count_specializations
)
238 int count_specializations
;
243 type
&& TREE_CODE (type
) != NAMESPACE_DECL
;
244 type
= (TREE_CODE (type
) == FUNCTION_DECL
)
245 ? DECL_REAL_CONTEXT (type
) : TYPE_CONTEXT (type
))
247 if (TREE_CODE (type
) != FUNCTION_DECL
)
249 if (CLASSTYPE_TEMPLATE_INFO (type
)
250 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
))
251 && ((count_specializations
252 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
253 || uses_template_parms (CLASSTYPE_TI_ARGS (type
))))
258 if (DECL_TEMPLATE_INFO (type
)
259 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type
))
260 && ((count_specializations
261 && DECL_TEMPLATE_SPECIALIZATION (type
))
262 || uses_template_parms (DECL_TI_ARGS (type
))))
270 /* Returns the template nesting level of the indicated class TYPE.
271 Like template_class_depth_real, but instantiations do not count in
275 template_class_depth (type
)
278 return template_class_depth_real (type
, /*count_specializations=*/0);
281 /* Returns 1 if processing DECL as part of do_pending_inlines
282 needs us to push template parms. */
285 inline_needs_template_parms (decl
)
288 if (! DECL_TEMPLATE_INFO (decl
))
291 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
292 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
295 /* Subroutine of maybe_begin_member_template_processing.
296 Push the template parms in PARMS, starting from LEVELS steps into the
297 chain, and ending at the beginning, since template parms are listed
301 push_inline_template_parms_recursive (parmlist
, levels
)
305 tree parms
= TREE_VALUE (parmlist
);
309 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
311 ++processing_template_decl
;
312 current_template_parms
313 = tree_cons (build_int_2 (0, processing_template_decl
),
314 parms
, current_template_parms
);
315 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
318 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
320 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
321 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (parm
)) == 'd', 0);
323 switch (TREE_CODE (parm
))
332 /* Make a CONST_DECL as is done in process_template_parm.
333 It is ugly that we recreate this here; the original
334 version built in process_template_parm is no longer
336 tree decl
= build_decl (CONST_DECL
, DECL_NAME (parm
),
338 SET_DECL_ARTIFICIAL (decl
);
339 DECL_INITIAL (decl
) = DECL_INITIAL (parm
);
340 SET_DECL_TEMPLATE_PARM_P (decl
);
346 my_friendly_abort (0);
351 /* Restore the template parameter context for a member template or
352 a friend template defined in a class definition. */
355 maybe_begin_member_template_processing (decl
)
361 if (inline_needs_template_parms (decl
))
363 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
364 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
366 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
369 parms
= TREE_CHAIN (parms
);
372 push_inline_template_parms_recursive (parms
, levels
);
375 /* Remember how many levels of template parameters we pushed so that
376 we can pop them later. */
377 if (!inline_parm_levels
)
378 VARRAY_INT_INIT (inline_parm_levels
, 4, "inline_parm_levels");
379 if (inline_parm_levels_used
== inline_parm_levels
->num_elements
)
380 VARRAY_GROW (inline_parm_levels
, 2 * inline_parm_levels_used
);
381 VARRAY_INT (inline_parm_levels
, inline_parm_levels_used
) = levels
;
382 ++inline_parm_levels_used
;
385 /* Undo the effects of begin_member_template_processing. */
388 maybe_end_member_template_processing ()
392 if (!inline_parm_levels_used
)
395 --inline_parm_levels_used
;
397 i
< VARRAY_INT (inline_parm_levels
, inline_parm_levels_used
);
400 --processing_template_decl
;
401 current_template_parms
= TREE_CHAIN (current_template_parms
);
406 /* Returns non-zero iff T is a member template function. We must be
409 template <class T> class C { void f(); }
411 Here, f is a template function, and a member, but not a member
412 template. This function does not concern itself with the origin of
413 T, only its present state. So if we have
415 template <class T> class C { template <class U> void f(U); }
417 then neither C<int>::f<char> nor C<T>::f<double> is considered
418 to be a member template. But, `template <class U> void
419 C<int>::f(U)' is considered a member template. */
422 is_member_template (t
)
425 if (!DECL_FUNCTION_TEMPLATE_P (t
))
426 /* Anything that isn't a function or a template function is
427 certainly not a member template. */
430 /* A local class can't have member templates. */
431 if (hack_decl_function_context (t
))
434 return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t
))
435 /* If there are more levels of template parameters than
436 there are template classes surrounding the declaration,
437 then we have a member template. */
438 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
439 template_class_depth (DECL_CLASS_CONTEXT (t
))));
443 /* Returns non-zero iff T is a member template class. See
444 is_member_template for a description of what precisely constitutes
445 a member template. */
448 is_member_template_class (t
)
451 if (!DECL_CLASS_TEMPLATE_P (t
))
452 /* Anything that isn't a class template, is certainly not a member
456 if (!DECL_CLASS_SCOPE_P (t
))
457 /* Anything whose context isn't a class type is surely not a
461 /* If there are more levels of template parameters than there are
462 template classes surrounding the declaration, then we have a
464 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t
)) >
465 template_class_depth (DECL_CONTEXT (t
)));
469 /* Return a new template argument vector which contains all of ARGS,
470 but has as its innermost set of arguments the EXTRA_ARGS. The
471 resulting vector will be built on a temporary obstack, and so must
472 be explicitly copied to the permanent obstack, if required. */
475 add_to_template_args (args
, extra_args
)
484 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
485 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
487 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
488 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
490 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
491 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
496 /* Like add_to_template_args, but only the outermost ARGS are added to
497 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
498 (EXTRA_ARGS) levels are added. This function is used to combine
499 the template arguments from a partial instantiation with the
500 template arguments used to attain the full instantiation from the
501 partial instantiation. */
504 add_outermost_template_args (args
, extra_args
)
510 /* If there are more levels of EXTRA_ARGS than there are ARGS,
511 something very fishy is going on. */
512 my_friendly_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
),
515 /* If *all* the new arguments will be the EXTRA_ARGS, just return
517 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
520 /* For the moment, we make ARGS look like it contains fewer levels. */
521 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
523 new_args
= add_to_template_args (args
, extra_args
);
525 /* Now, we restore ARGS to its full dimensions. */
526 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
531 /* We've got a template header coming up; push to a new level for storing
535 begin_template_parm_list ()
537 /* We use a non-tag-transparent scope here, which causes pushtag to
538 put tags in this scope, rather than in the enclosing class or
539 namespace scope. This is the right thing, since we want
540 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
541 global template class, push_template_decl handles putting the
542 TEMPLATE_DECL into top-level scope. For a nested template class,
545 template <class T> struct S1 {
546 template <class T> struct S2 {};
549 pushtag contains special code to call pushdecl_with_scope on the
550 TEMPLATE_DECL for S2. */
552 declare_pseudo_global_level ();
553 ++processing_template_decl
;
554 ++processing_template_parmlist
;
555 note_template_header (0);
558 /* This routine is called when a specialization is declared. If it is
559 illegal to declare a specialization here, an error is reported. */
562 check_specialization_scope ()
564 tree scope
= current_scope ();
568 An explicit specialization shall be declared in the namespace of
569 which the template is a member, or, for member templates, in the
570 namespace of which the enclosing class or enclosing class
571 template is a member. An explicit specialization of a member
572 function, member class or static data member of a class template
573 shall be declared in the namespace of which the class template
575 if (scope
&& TREE_CODE (scope
) != NAMESPACE_DECL
)
576 cp_error ("explicit specialization in non-namespace scope `%D'",
581 In an explicit specialization declaration for a member of a class
582 template or a member template that appears in namespace scope,
583 the member template and some of its enclosing class templates may
584 remain unspecialized, except that the declaration shall not
585 explicitly specialize a class member template if its enclosing
586 class templates are not explicitly specialized as well. */
587 if (current_template_parms
)
588 cp_error ("enclosing class templates are not explicitly specialized");
591 /* We've just seen template <>. */
594 begin_specialization ()
596 note_template_header (1);
597 check_specialization_scope ();
600 /* Called at then end of processing a declaration preceeded by
604 end_specialization ()
606 reset_specialization ();
609 /* Any template <>'s that we have seen thus far are not referring to a
610 function specialization. */
613 reset_specialization ()
615 processing_specialization
= 0;
616 template_header_count
= 0;
619 /* We've just seen a template header. If SPECIALIZATION is non-zero,
620 it was of the form template <>. */
623 note_template_header (specialization
)
626 processing_specialization
= specialization
;
627 template_header_count
++;
630 /* We're beginning an explicit instantiation. */
633 begin_explicit_instantiation ()
635 ++processing_explicit_instantiation
;
640 end_explicit_instantiation ()
642 my_friendly_assert(processing_explicit_instantiation
> 0, 0);
643 --processing_explicit_instantiation
;
646 /* The TYPE is being declared. If it is a template type, that means it
647 is a partial specialization. Do appropriate error-checking. */
650 maybe_process_partial_specialization (type
)
653 if (IS_AGGR_TYPE (type
) && CLASSTYPE_USE_TEMPLATE (type
))
655 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
656 && TYPE_SIZE (type
) == NULL_TREE
)
658 if (current_namespace
659 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type
)))
661 cp_pedwarn ("specializing `%#T' in different namespace", type
);
662 cp_pedwarn_at (" from definition of `%#D'",
663 CLASSTYPE_TI_TEMPLATE (type
));
665 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
666 if (processing_template_decl
)
667 push_template_decl (TYPE_MAIN_DECL (type
));
669 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
670 cp_error ("specialization of `%T' after instantiation", type
);
672 else if (processing_specialization
)
673 cp_error ("explicit specialization of non-template `%T'", type
);
676 /* Retrieve the specialization (in the sense of [temp.spec] - a
677 specialization is either an instantiation or an explicit
678 specialization) of TMPL for the given template ARGS. If there is
679 no such specialization, return NULL_TREE. The ARGS are a vector of
680 arguments, or a vector of vectors of arguments, in the case of
681 templates with more than one level of parameters. */
684 retrieve_specialization (tmpl
, args
)
690 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
692 /* There should be as many levels of arguments as there are
693 levels of parameters. */
694 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
695 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
698 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
701 if (comp_template_args (TREE_PURPOSE (s
), args
))
702 return TREE_VALUE (s
);
707 /* Like retrieve_speciailization, but for local declarations. FN is
708 the function in which we are looking for an instantiation. */
711 retrieve_local_specialization (tmpl
, fn
)
715 tree s
= purpose_member (fn
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
716 return s
? TREE_VALUE (s
) : NULL_TREE
;
719 /* Returns non-zero iff DECL is a specialization of TMPL. */
722 is_specialization_of (decl
, tmpl
)
728 if (TREE_CODE (decl
) == FUNCTION_DECL
)
732 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
738 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 0);
740 for (t
= TREE_TYPE (decl
);
742 t
= CLASSTYPE_USE_TEMPLATE (t
)
743 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
744 if (same_type_p (TYPE_MAIN_VARIANT (t
),
745 TYPE_MAIN_VARIANT (TREE_TYPE (tmpl
))))
752 /* Register the specialization SPEC as a specialization of TMPL with
753 the indicated ARGS. Returns SPEC, or an equivalent prior
754 declaration, if available. */
757 register_specialization (spec
, tmpl
, args
)
764 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 0);
766 if (TREE_CODE (spec
) == FUNCTION_DECL
767 && uses_template_parms (DECL_TI_ARGS (spec
)))
768 /* This is the FUNCTION_DECL for a partial instantiation. Don't
769 register it; we want the corresponding TEMPLATE_DECL instead.
770 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
771 the more obvious `uses_template_parms (spec)' to avoid problems
772 with default function arguments. In particular, given
775 template <class T> void f(T t1, T t = T())
777 the default argument expression is not substituted for in an
778 instantiation unless and until it is actually needed. */
781 /* There should be as many levels of arguments as there are
782 levels of parameters. */
783 my_friendly_assert (TMPL_ARGS_DEPTH (args
)
784 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
)),
787 for (s
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
791 tree fn
= TREE_VALUE (s
);
793 /* We can sometimes try to re-register a specialization that we've
794 already got. In particular, regenerate_decl_from_template
795 calls duplicate_decls which will update the specialization
796 list. But, we'll still get called again here anyhow. It's
797 more convenient to simply allow this than to try to prevent it. */
800 else if (comp_template_args (TREE_PURPOSE (s
), args
))
802 if (DECL_TEMPLATE_SPECIALIZATION (spec
))
804 if (DECL_TEMPLATE_INSTANTIATION (fn
))
807 || DECL_EXPLICIT_INSTANTIATION (fn
))
809 cp_error ("specialization of %D after instantiation",
815 /* This situation should occur only if the first
816 specialization is an implicit instantiation,
817 the second is an explicit specialization, and
818 the implicit instantiation has not yet been
819 used. That situation can occur if we have
820 implicitly instantiated a member function and
821 then specialized it later.
823 We can also wind up here if a friend
824 declaration that looked like an instantiation
825 turns out to be a specialization:
827 template <class T> void foo(T);
828 class S { friend void foo<>(int) };
829 template <> void foo(int);
831 We transform the existing DECL in place so that
832 any pointers to it become pointers to the
835 If there was a definition for the template, but
836 not for the specialization, we want this to
837 look as if there is no definition, and vice
839 DECL_INITIAL (fn
) = NULL_TREE
;
840 duplicate_decls (spec
, fn
);
845 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
847 duplicate_decls (spec
, fn
);
854 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
855 = tree_cons (args
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
860 /* Unregister the specialization SPEC as a specialization of TMPL.
861 Returns nonzero if the SPEC was listed as a specialization of
865 unregister_specialization (spec
, tmpl
)
871 for (s
= &DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
873 s
= &TREE_CHAIN (*s
))
874 if (TREE_VALUE (*s
) == spec
)
876 *s
= TREE_CHAIN (*s
);
883 /* Like register_specialization, but for local declarations. FN is
884 the function in which we are registering SPEC, an instantiation of
888 register_local_specialization (spec
, tmpl
, fn
)
893 DECL_TEMPLATE_SPECIALIZATIONS (tmpl
)
894 = tree_cons (fn
, spec
, DECL_TEMPLATE_SPECIALIZATIONS (tmpl
));
899 /* Print the list of candidate FNS in an error message. */
902 print_candidates (fns
)
907 const char *str
= "candidates are:";
909 for (fn
= fns
; fn
!= NULL_TREE
; fn
= TREE_CHAIN (fn
))
913 for (f
= TREE_VALUE (fn
); f
; f
= OVL_NEXT (f
))
914 cp_error_at ("%s %+#D", str
, OVL_CURRENT (f
));
919 /* Returns the template (one of the functions given by TEMPLATE_ID)
920 which can be specialized to match the indicated DECL with the
921 explicit template args given in TEMPLATE_ID. The DECL may be
922 NULL_TREE if none is available. In that case, the functions in
923 TEMPLATE_ID are non-members.
925 If NEED_MEMBER_TEMPLATE is non-zero the function is known to be a
926 specialization of a member template.
928 The template args (those explicitly specified and those deduced)
929 are output in a newly created vector *TARGS_OUT.
931 If it is impossible to determine the result, an error message is
932 issued. The error_mark_node is returned to indicate failure. */
935 determine_specialization (template_id
, decl
, targs_out
,
936 need_member_template
)
940 int need_member_template
;
945 tree candidates
= NULL_TREE
;
946 tree templates
= NULL_TREE
;
948 *targs_out
= NULL_TREE
;
950 if (template_id
== error_mark_node
)
951 return error_mark_node
;
953 fns
= TREE_OPERAND (template_id
, 0);
954 explicit_targs
= TREE_OPERAND (template_id
, 1);
956 if (fns
== error_mark_node
)
957 return error_mark_node
;
959 /* Check for baselinks. */
960 if (BASELINK_P (fns
))
961 fns
= TREE_VALUE (fns
);
963 if (!is_overloaded_fn (fns
))
965 cp_error ("`%D' is not a function template", fns
);
966 return error_mark_node
;
969 for (; fns
; fns
= OVL_NEXT (fns
))
973 tree fn
= OVL_CURRENT (fns
);
975 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
976 /* DECL might be a specialization of FN. */
978 else if (need_member_template
)
979 /* FN is an ordinary member function, and we need a
980 specialization of a member template. */
982 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
983 /* We can get IDENTIFIER_NODEs here in certain erroneous
986 else if (!DECL_FUNCTION_MEMBER_P (fn
))
987 /* This is just an ordinary non-member function. Nothing can
988 be a specialization of that. */
994 /* This is an ordinary member function. However, since
995 we're here, we can assume it's enclosing class is a
996 template class. For example,
998 template <typename T> struct S { void f(); };
999 template <> void S<int>::f() {}
1001 Here, S<int>::f is a non-template, but S<int> is a
1002 template class. If FN has the same type as DECL, we
1003 might be in business. */
1004 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
1005 TREE_TYPE (TREE_TYPE (fn
))))
1006 /* The return types differ. */
1009 /* Adjust the type of DECL in case FN is a static member. */
1010 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1011 if (DECL_STATIC_FUNCTION_P (fn
)
1012 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1013 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
1015 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
1018 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
1023 /* See whether this function might be a specialization of this
1025 targs
= get_bindings (tmpl
, decl
, explicit_targs
);
1028 /* We cannot deduce template arguments that when used to
1029 specialize TMPL will produce DECL. */
1032 /* Save this template, and the arguments deduced. */
1033 templates
= tree_cons (targs
, tmpl
, templates
);
1036 if (templates
&& TREE_CHAIN (templates
))
1042 It is possible for a specialization with a given function
1043 signature to be instantiated from more than one function
1044 template. In such cases, explicit specification of the
1045 template arguments must be used to uniquely identify the
1046 function template specialization being specialized.
1048 Note that here, there's no suggestion that we're supposed to
1049 determine which of the candidate templates is most
1050 specialized. However, we, also have:
1054 Partial ordering of overloaded function template
1055 declarations is used in the following contexts to select
1056 the function template to which a function template
1057 specialization refers:
1059 -- when an explicit specialization refers to a function
1062 So, we do use the partial ordering rules, at least for now.
1063 This extension can only serve to make illegal programs legal,
1064 so it's safe. And, there is strong anecdotal evidence that
1065 the committee intended the partial ordering rules to apply;
1066 the EDG front-end has that behavior, and John Spicer claims
1067 that the committee simply forgot to delete the wording in
1068 [temp.expl.spec]. */
1069 tree tmpl
= most_specialized (templates
, decl
, explicit_targs
);
1070 if (tmpl
&& tmpl
!= error_mark_node
)
1072 targs
= get_bindings (tmpl
, decl
, explicit_targs
);
1073 templates
= tree_cons (targs
, tmpl
, NULL_TREE
);
1077 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
1079 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
1081 return error_mark_node
;
1083 else if ((templates
&& TREE_CHAIN (templates
))
1084 || (candidates
&& TREE_CHAIN (candidates
))
1085 || (templates
&& candidates
))
1087 cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1089 chainon (candidates
, templates
);
1090 print_candidates (candidates
);
1091 return error_mark_node
;
1094 /* We have one, and exactly one, match. */
1097 /* It was a specialization of an ordinary member function in a
1099 *targs_out
= copy_node (DECL_TI_ARGS (TREE_VALUE (candidates
)));
1100 return DECL_TI_TEMPLATE (TREE_VALUE (candidates
));
1103 /* It was a specialization of a template. */
1104 targs
= DECL_TI_ARGS (DECL_RESULT (TREE_VALUE (templates
)));
1105 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
1107 *targs_out
= copy_node (targs
);
1108 SET_TMPL_ARGS_LEVEL (*targs_out
,
1109 TMPL_ARGS_DEPTH (*targs_out
),
1110 TREE_PURPOSE (templates
));
1113 *targs_out
= TREE_PURPOSE (templates
);
1114 return TREE_VALUE (templates
);
1117 /* Check to see if the function just declared, as indicated in
1118 DECLARATOR, and in DECL, is a specialization of a function
1119 template. We may also discover that the declaration is an explicit
1120 instantiation at this point.
1122 Returns DECL, or an equivalent declaration that should be used
1123 instead if all goes well. Issues an error message if something is
1124 amiss. Returns error_mark_node if the error is not easily
1127 FLAGS is a bitmask consisting of the following flags:
1129 2: The function has a definition.
1130 4: The function is a friend.
1132 The TEMPLATE_COUNT is the number of references to qualifying
1133 template classes that appeared in the name of the function. For
1136 template <class T> struct S { void f(); };
1139 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1140 classes are not counted in the TEMPLATE_COUNT, so that in
1142 template <class T> struct S {};
1143 template <> struct S<int> { void f(); }
1144 template <> void S<int>::f();
1146 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1147 illegal; there should be no template <>.)
1149 If the function is a specialization, it is marked as such via
1150 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1151 is set up correctly, and it is added to the list of specializations
1152 for that template. */
1155 check_explicit_specialization (declarator
, decl
, template_count
, flags
)
1161 int have_def
= flags
& 2;
1162 int is_friend
= flags
& 4;
1163 int specialization
= 0;
1164 int explicit_instantiation
= 0;
1165 int member_specialization
= 0;
1167 tree ctype
= DECL_CLASS_CONTEXT (decl
);
1168 tree dname
= DECL_NAME (decl
);
1170 if (processing_specialization
)
1172 /* The last template header was of the form template <>. */
1174 if (template_header_count
> template_count
)
1176 /* There were more template headers than qualifying template
1178 if (template_header_count
- template_count
> 1)
1179 /* There shouldn't be that many template parameter lists.
1180 There can be at most one parameter list for every
1181 qualifying class, plus one for the function itself. */
1182 cp_error ("too many template parameter lists in declaration of `%D'", decl
);
1184 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1186 member_specialization
= 1;
1190 else if (template_header_count
== template_count
)
1192 /* The counts are equal. So, this might be a
1193 specialization, but it is not a specialization of a
1194 member template. It might be something like
1196 template <class T> struct S {
1200 void S<int>::f(int i) {} */
1202 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1206 /* This cannot be an explicit specialization. There are not
1207 enough headers for all of the qualifying classes. For
1208 example, we might have:
1211 void S<int>::T<char>::f();
1213 But, we're missing another template <>. */
1214 cp_error("too few template parameter lists in declaration of `%D'", decl
);
1218 else if (processing_explicit_instantiation
)
1220 if (template_header_count
)
1221 cp_error ("template parameter list used in explicit instantiation");
1224 cp_error ("definition provided for explicit instantiation");
1226 explicit_instantiation
= 1;
1228 else if (ctype
!= NULL_TREE
1229 && !TYPE_BEING_DEFINED (ctype
)
1230 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
)
1233 /* This case catches outdated code that looks like this:
1235 template <class T> struct S { void f(); };
1236 void S<int>::f() {} // Missing template <>
1238 We disable this check when the type is being defined to
1239 avoid complaining about default compiler-generated
1240 constructors, destructors, and assignment operators.
1241 Since the type is an instantiation, not a specialization,
1242 these are the only functions that can be defined before
1243 the class is complete. */
1246 template <class T> void S<int>::f() {}
1248 if (template_header_count
)
1250 cp_error ("template parameters specified in specialization");
1256 ("explicit specialization not preceded by `template <>'");
1258 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
1260 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
1263 /* This could be something like:
1265 template <class T> void f(T);
1266 class S { friend void f<>(int); } */
1270 /* This case handles bogus declarations like template <>
1271 template <class T> void f<int>(); */
1273 cp_error ("template-id `%D' in declaration of primary template",
1279 if (specialization
|| member_specialization
)
1281 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
1282 for (; t
; t
= TREE_CHAIN (t
))
1283 if (TREE_PURPOSE (t
))
1286 ("default argument specified in explicit specialization");
1289 if (current_lang_name
== lang_name_c
)
1290 cp_error ("template specialization with C linkage");
1293 if (specialization
|| member_specialization
|| explicit_instantiation
)
1295 tree tmpl
= NULL_TREE
;
1296 tree targs
= NULL_TREE
;
1298 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1299 if (TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
1303 my_friendly_assert (TREE_CODE (declarator
) == IDENTIFIER_NODE
,
1306 fns
= IDENTIFIER_NAMESPACE_VALUE (dname
);
1311 lookup_template_function (fns
, NULL_TREE
);
1314 if (declarator
== error_mark_node
)
1315 return error_mark_node
;
1317 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
1319 if (!explicit_instantiation
)
1320 /* A specialization in class scope. This is illegal,
1321 but the error will already have been flagged by
1322 check_specialization_scope. */
1323 return error_mark_node
;
1326 /* It's not legal to write an explicit instantiation in
1329 class C { template void f(); }
1331 This case is caught by the parser. However, on
1334 template class C { void f(); };
1336 (which is illegal) we can get here. The error will be
1343 else if (TREE_CODE (TREE_OPERAND (declarator
, 0)) == LOOKUP_EXPR
)
1345 /* A friend declaration. We can't do much, because we don't
1346 know what this resolves to, yet. */
1347 my_friendly_assert (is_friend
!= 0, 0);
1348 my_friendly_assert (!explicit_instantiation
, 0);
1349 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1352 else if (ctype
!= NULL_TREE
1353 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) ==
1356 /* Find the list of functions in ctype that have the same
1357 name as the declared function. */
1358 tree name
= TREE_OPERAND (declarator
, 0);
1359 tree fns
= NULL_TREE
;
1362 if (name
== constructor_name (ctype
)
1363 || name
== constructor_name_full (ctype
))
1365 int is_constructor
= DECL_CONSTRUCTOR_P (decl
);
1367 if (is_constructor
? !TYPE_HAS_CONSTRUCTOR (ctype
)
1368 : !TYPE_HAS_DESTRUCTOR (ctype
))
1370 /* From [temp.expl.spec]:
1372 If such an explicit specialization for the member
1373 of a class template names an implicitly-declared
1374 special member function (clause _special_), the
1375 program is ill-formed.
1377 Similar language is found in [temp.explicit]. */
1378 cp_error ("specialization of implicitly-declared special member function");
1379 return error_mark_node
;
1382 name
= is_constructor
? ctor_identifier
: dtor_identifier
;
1385 if (!IDENTIFIER_TYPENAME_P (name
))
1387 idx
= lookup_fnfields_1 (ctype
, name
);
1389 fns
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype
), idx
);
1395 /* For a type-conversion operator, we cannot do a
1396 name-based lookup. We might be looking for `operator
1397 int' which will be a specialization of `operator T'.
1398 So, we find *all* the conversion operators, and then
1399 select from them. */
1402 methods
= CLASSTYPE_METHOD_VEC (ctype
);
1404 for (idx
= 2; idx
< TREE_VEC_LENGTH (methods
); ++idx
)
1406 tree ovl
= TREE_VEC_ELT (methods
, idx
);
1408 if (!ovl
|| !DECL_CONV_FN_P (OVL_CURRENT (ovl
)))
1409 /* There are no more conversion functions. */
1412 /* Glue all these conversion functions together
1413 with those we already have. */
1414 for (; ovl
; ovl
= OVL_NEXT (ovl
))
1415 fns
= ovl_cons (OVL_CURRENT (ovl
), fns
);
1419 if (fns
== NULL_TREE
)
1421 cp_error ("no member function `%D' declared in `%T'",
1423 return error_mark_node
;
1426 TREE_OPERAND (declarator
, 0) = fns
;
1429 /* Figure out what exactly is being specialized at this point.
1430 Note that for an explicit instantiation, even one for a
1431 member function, we cannot tell apriori whether the
1432 instantiation is for a member template, or just a member
1433 function of a template class. Even if a member template is
1434 being instantiated, the member template arguments may be
1435 elided if they can be deduced from the rest of the
1437 tmpl
= determine_specialization (declarator
, decl
,
1439 member_specialization
);
1441 if (!tmpl
|| tmpl
== error_mark_node
)
1442 /* We couldn't figure out what this declaration was
1444 return error_mark_node
;
1447 tree gen_tmpl
= most_general_template (tmpl
);
1449 if (explicit_instantiation
)
1451 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1452 is done by do_decl_instantiation later. */
1454 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
1455 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
1457 if (arg_depth
> parm_depth
)
1459 /* If TMPL is not the most general template (for
1460 example, if TMPL is a friend template that is
1461 injected into namespace scope), then there will
1462 be too many levels fo TARGS. Remove some of them
1467 new_targs
= make_tree_vec (parm_depth
);
1468 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
1469 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
1470 = TREE_VEC_ELT (targs
, i
);
1474 decl
= instantiate_template (tmpl
, targs
);
1478 /* If we though that the DECL was a member function, but it
1479 turns out to be specializing a static member function,
1480 make DECL a static member function as well. */
1481 if (DECL_STATIC_FUNCTION_P (tmpl
)
1482 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1484 revert_static_member_fn (&decl
, 0, 0);
1485 last_function_parms
= TREE_CHAIN (last_function_parms
);
1488 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1489 DECL_TEMPLATE_INFO (decl
) = tree_cons (tmpl
, targs
, NULL_TREE
);
1491 /* Mangle the function name appropriately. Note that we do
1492 not mangle specializations of non-template member
1493 functions of template classes, e.g. with
1495 template <class T> struct S { void f(); }
1497 and given the specialization
1499 template <> void S<int>::f() {}
1501 we do not mangle S<int>::f() here. That's because it's
1502 just an ordinary member function and doesn't need special
1503 treatment. We do this here so that the ordinary,
1504 non-template, name-mangling algorith will not be used
1506 if ((is_member_template (tmpl
) || ctype
== NULL_TREE
)
1507 && name_mangling_version
>= 1)
1508 set_mangled_name_for_template_decl (decl
);
1510 if (is_friend
&& !have_def
)
1511 /* This is not really a declaration of a specialization.
1512 It's just the name of an instantiation. But, it's not
1513 a request for an instantiation, either. */
1514 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
1516 /* Register this specialization so that we can find it
1518 decl
= register_specialization (decl
, gen_tmpl
, targs
);
1525 /* TYPE is being declared. Verify that the use of template headers
1526 and such is reasonable. Issue error messages if not. */
1529 maybe_check_template_type (type
)
1532 if (template_header_count
)
1534 /* We are in the scope of some `template <...>' header. */
1537 = template_class_depth_real (TYPE_CONTEXT (type
),
1538 /*count_specializations=*/1);
1540 if (template_header_count
<= context_depth
)
1541 /* This is OK; the template headers are for the context. We
1542 are actually too lenient here; like
1543 check_explicit_specialization we should consider the number
1544 of template types included in the actual declaration. For
1547 template <class T> struct S {
1548 template <class U> template <class V>
1554 template <class T> struct S {
1555 template <class U> struct I;
1558 template <class T> template <class U.
1563 else if (template_header_count
> context_depth
+ 1)
1564 /* There are two many template parameter lists. */
1565 cp_error ("too many template parameter lists in declaration of `%T'", type
);
1569 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
1570 parameters. These are represented in the same format used for
1571 DECL_TEMPLATE_PARMS. */
1573 int comp_template_parms (parms1
, parms2
)
1580 if (parms1
== parms2
)
1583 for (p1
= parms1
, p2
= parms2
;
1584 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
1585 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
1587 tree t1
= TREE_VALUE (p1
);
1588 tree t2
= TREE_VALUE (p2
);
1591 my_friendly_assert (TREE_CODE (t1
) == TREE_VEC
, 0);
1592 my_friendly_assert (TREE_CODE (t2
) == TREE_VEC
, 0);
1594 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
1597 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
1599 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
1600 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
1602 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
1605 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
)
1607 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
1612 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
1613 /* One set of parameters has more parameters lists than the
1620 /* Complain if DECL shadows a template parameter.
1622 [temp.local]: A template-parameter shall not be redeclared within its
1623 scope (including nested scopes). */
1626 check_template_shadow (decl
)
1631 /* If we're not in a template, we can't possibly shadow a template
1633 if (!current_template_parms
)
1636 /* Figure out what we're shadowing. */
1637 if (TREE_CODE (decl
) == OVERLOAD
)
1638 decl
= OVL_CURRENT (decl
);
1639 olddecl
= IDENTIFIER_VALUE (DECL_NAME (decl
));
1641 /* If there's no previous binding for this name, we're not shadowing
1642 anything, let alone a template parameter. */
1646 /* If we're not shadowing a template parameter, we're done. Note
1647 that OLDDECL might be an OVERLOAD (or perhaps even an
1648 ERROR_MARK), so we can't just blithely assume it to be a _DECL
1650 if (TREE_CODE_CLASS (TREE_CODE (olddecl
)) != 'd'
1651 || !DECL_TEMPLATE_PARM_P (olddecl
))
1654 /* We check for decl != olddecl to avoid bogus errors for using a
1655 name inside a class. We check TPFI to avoid duplicate errors for
1656 inline member templates. */
1658 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms
))
1661 cp_error_at ("declaration of `%#D'", decl
);
1662 cp_error_at (" shadows template parm `%#D'", olddecl
);
1665 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
1666 ORIG_LEVEL, DECL, and TYPE. */
1669 build_template_parm_index (index
, level
, orig_level
, decl
, type
)
1676 tree t
= make_node (TEMPLATE_PARM_INDEX
);
1677 TEMPLATE_PARM_IDX (t
) = index
;
1678 TEMPLATE_PARM_LEVEL (t
) = level
;
1679 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
1680 TEMPLATE_PARM_DECL (t
) = decl
;
1681 TREE_TYPE (t
) = type
;
1686 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
1687 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
1688 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
1689 new one is created. */
1692 reduce_template_parm_level (index
, type
, levels
)
1697 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
1698 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
1699 != TEMPLATE_PARM_LEVEL (index
) - levels
))
1702 = build_decl (TREE_CODE (TEMPLATE_PARM_DECL (index
)),
1703 DECL_NAME (TEMPLATE_PARM_DECL (index
)),
1706 = build_template_parm_index (TEMPLATE_PARM_IDX (index
),
1707 TEMPLATE_PARM_LEVEL (index
) - levels
,
1708 TEMPLATE_PARM_ORIG_LEVEL (index
),
1710 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
1712 /* Template template parameters need this. */
1713 DECL_TEMPLATE_PARMS (decl
)
1714 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index
));
1717 return TEMPLATE_PARM_DESCENDANTS (index
);
1720 /* Process information from new template parameter NEXT and append it to the
1721 LIST being built. */
1724 process_template_parm (list
, next
)
1733 my_friendly_assert (TREE_CODE (parm
) == TREE_LIST
, 259);
1734 defval
= TREE_PURPOSE (parm
);
1735 parm
= TREE_VALUE (parm
);
1736 is_type
= TREE_PURPOSE (parm
) == class_type_node
;
1740 tree p
= TREE_VALUE (tree_last (list
));
1742 if (TREE_CODE (p
) == TYPE_DECL
)
1743 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
1744 else if (TREE_CODE (p
) == TEMPLATE_DECL
)
1745 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (DECL_TEMPLATE_RESULT (p
)));
1747 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
1755 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm
)) == TREE_LIST
, 260);
1756 /* is a const-param */
1757 parm
= grokdeclarator (TREE_VALUE (parm
), TREE_PURPOSE (parm
),
1758 PARM
, 0, NULL_TREE
);
1762 The top-level cv-qualifiers on the template-parameter are
1763 ignored when determining its type. */
1764 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
1766 /* A template parameter is not modifiable. */
1767 TREE_READONLY (parm
) = 1;
1768 if (IS_AGGR_TYPE (TREE_TYPE (parm
))
1769 && TREE_CODE (TREE_TYPE (parm
)) != TEMPLATE_TYPE_PARM
1770 && TREE_CODE (TREE_TYPE (parm
)) != TYPENAME_TYPE
)
1772 cp_error ("`%#T' is not a valid type for a template constant parameter",
1774 if (DECL_NAME (parm
) == NULL_TREE
)
1775 error (" a template type parameter must begin with `class' or `typename'");
1776 TREE_TYPE (parm
) = void_type_node
;
1779 && (TREE_CODE (TREE_TYPE (parm
)) == REAL_TYPE
1780 || TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
))
1781 cp_pedwarn ("`%T' is not a valid type for a template constant parameter",
1783 decl
= build_decl (CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
1784 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
1785 = build_template_parm_index (idx
, processing_template_decl
,
1786 processing_template_decl
,
1787 decl
, TREE_TYPE (parm
));
1792 parm
= TREE_VALUE (parm
);
1794 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
1796 t
= make_lang_type (TEMPLATE_TEMPLATE_PARM
);
1797 /* This is for distinguishing between real templates and template
1798 template parameters */
1799 TREE_TYPE (parm
) = t
;
1800 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
1805 t
= make_lang_type (TEMPLATE_TYPE_PARM
);
1806 /* parm is either IDENTIFIER_NODE or NULL_TREE */
1807 decl
= build_decl (TYPE_DECL
, parm
, t
);
1810 TYPE_NAME (t
) = decl
;
1811 TYPE_STUB_DECL (t
) = decl
;
1813 TEMPLATE_TYPE_PARM_INDEX (t
)
1814 = build_template_parm_index (idx
, processing_template_decl
,
1815 processing_template_decl
,
1816 decl
, TREE_TYPE (parm
));
1818 SET_DECL_ARTIFICIAL (decl
);
1819 SET_DECL_TEMPLATE_PARM_P (decl
);
1821 parm
= build_tree_list (defval
, parm
);
1822 return chainon (list
, parm
);
1825 /* The end of a template parameter list has been reached. Process the
1826 tree list into a parameter vector, converting each parameter into a more
1827 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
1831 end_template_parm_list (parms
)
1836 tree saved_parmlist
= make_tree_vec (list_length (parms
));
1838 current_template_parms
1839 = tree_cons (build_int_2 (0, processing_template_decl
),
1840 saved_parmlist
, current_template_parms
);
1842 for (parm
= parms
, nparms
= 0;
1844 parm
= TREE_CHAIN (parm
), nparms
++)
1845 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
1847 --processing_template_parmlist
;
1849 return saved_parmlist
;
1852 /* end_template_decl is called after a template declaration is seen. */
1855 end_template_decl ()
1857 reset_specialization ();
1859 if (! processing_template_decl
)
1862 /* This matches the pushlevel in begin_template_parm_list. */
1865 --processing_template_decl
;
1866 current_template_parms
= TREE_CHAIN (current_template_parms
);
1867 (void) get_pending_sizes (); /* Why? */
1870 /* Given a template argument vector containing the template PARMS.
1871 The innermost PARMS are given first. */
1874 current_template_args ()
1877 tree args
= NULL_TREE
;
1878 int length
= TMPL_PARMS_DEPTH (current_template_parms
);
1881 /* If there is only one level of template parameters, we do not
1882 create a TREE_VEC of TREE_VECs. Instead, we return a single
1883 TREE_VEC containing the arguments. */
1885 args
= make_tree_vec (length
);
1887 for (header
= current_template_parms
; header
; header
= TREE_CHAIN (header
))
1889 tree a
= copy_node (TREE_VALUE (header
));
1892 TREE_TYPE (a
) = NULL_TREE
;
1893 for (i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
1895 tree t
= TREE_VEC_ELT (a
, i
);
1897 /* T will be a list if we are called from within a
1898 begin/end_template_parm_list pair, but a vector directly
1899 if within a begin/end_member_template_processing pair. */
1900 if (TREE_CODE (t
) == TREE_LIST
)
1904 if (TREE_CODE (t
) == TYPE_DECL
1905 || TREE_CODE (t
) == TEMPLATE_DECL
)
1908 t
= DECL_INITIAL (t
);
1909 TREE_VEC_ELT (a
, i
) = t
;
1914 TREE_VEC_ELT (args
, --l
) = a
;
1922 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
1923 template PARMS. Used by push_template_decl below. */
1926 build_template_decl (decl
, parms
)
1930 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
1931 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
1932 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
1933 if (DECL_LANG_SPECIFIC (decl
))
1935 DECL_CLASS_CONTEXT (tmpl
) = DECL_CLASS_CONTEXT (decl
);
1936 DECL_STATIC_FUNCTION_P (tmpl
) = DECL_STATIC_FUNCTION_P (decl
);
1937 DECL_CONSTRUCTOR_P (tmpl
) = DECL_CONSTRUCTOR_P (decl
);
1938 DECL_NONCONVERTING_P (tmpl
) = DECL_NONCONVERTING_P (decl
);
1944 struct template_parm_data
1946 /* The level of the template parameters we are currently
1950 /* The index of the specialization argument we are currently
1954 /* An array whose size is the number of template parameters. The
1955 elements are non-zero if the parameter has been used in any one
1956 of the arguments processed so far. */
1959 /* An array whose size is the number of template arguments. The
1960 elements are non-zero if the argument makes use of template
1961 parameters of this level. */
1962 int* arg_uses_template_parms
;
1965 /* Subroutine of push_template_decl used to see if each template
1966 parameter in a partial specialization is used in the explicit
1967 argument list. If T is of the LEVEL given in DATA (which is
1968 treated as a template_parm_data*), then DATA->PARMS is marked
1972 mark_template_parm (t
, data
)
1978 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
1980 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
1982 level
= TEMPLATE_PARM_LEVEL (t
);
1983 idx
= TEMPLATE_PARM_IDX (t
);
1987 level
= TEMPLATE_TYPE_LEVEL (t
);
1988 idx
= TEMPLATE_TYPE_IDX (t
);
1991 if (level
== tpd
->level
)
1993 tpd
->parms
[idx
] = 1;
1994 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
1997 /* Return zero so that for_each_template_parm will continue the
1998 traversal of the tree; we want to mark *every* template parm. */
2002 /* Process the partial specialization DECL. */
2005 process_partial_specialization (decl
)
2008 tree type
= TREE_TYPE (decl
);
2009 tree maintmpl
= CLASSTYPE_TI_TEMPLATE (type
);
2010 tree specargs
= CLASSTYPE_TI_ARGS (type
);
2011 tree inner_args
= innermost_args (specargs
);
2012 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
2013 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
2014 int nargs
= TREE_VEC_LENGTH (inner_args
);
2015 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
2017 int did_error_intro
= 0;
2018 struct template_parm_data tpd
;
2019 struct template_parm_data tpd2
;
2021 /* We check that each of the template parameters given in the
2022 partial specialization is used in the argument list to the
2023 specialization. For example:
2025 template <class T> struct S;
2026 template <class T> struct S<T*>;
2028 The second declaration is OK because `T*' uses the template
2029 parameter T, whereas
2031 template <class T> struct S<int>;
2033 is no good. Even trickier is:
2044 The S2<T> declaration is actually illegal; it is a
2045 full-specialization. Of course,
2048 struct S2<T (*)(U)>;
2050 or some such would have been OK. */
2051 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
2052 tpd
.parms
= alloca (sizeof (int) * ntparms
);
2053 bzero ((PTR
) tpd
.parms
, sizeof (int) * ntparms
);
2055 tpd
.arg_uses_template_parms
= alloca (sizeof (int) * nargs
);
2056 bzero ((PTR
) tpd
.arg_uses_template_parms
, sizeof (int) * nargs
);
2057 for (i
= 0; i
< nargs
; ++i
)
2059 tpd
.current_arg
= i
;
2060 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
2061 &mark_template_parm
,
2064 for (i
= 0; i
< ntparms
; ++i
)
2065 if (tpd
.parms
[i
] == 0)
2067 /* One of the template parms was not used in the
2069 if (!did_error_intro
)
2071 cp_error ("template parameters not used in partial specialization:");
2072 did_error_intro
= 1;
2076 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
2079 /* [temp.class.spec]
2081 The argument list of the specialization shall not be identical to
2082 the implicit argument list of the primary template. */
2083 if (comp_template_args (inner_args
,
2084 innermost_args (CLASSTYPE_TI_ARGS (TREE_TYPE
2086 cp_error ("partial specialization `%T' does not specialize any template arguments", type
);
2088 /* [temp.class.spec]
2090 A partially specialized non-type argument expression shall not
2091 involve template parameters of the partial specialization except
2092 when the argument expression is a simple identifier.
2094 The type of a template parameter corresponding to a specialized
2095 non-type argument shall not be dependent on a parameter of the
2097 my_friendly_assert (nargs
== DECL_NTPARMS (maintmpl
), 0);
2099 for (i
= 0; i
< nargs
; ++i
)
2101 tree arg
= TREE_VEC_ELT (inner_args
, i
);
2102 if (/* These first two lines are the `non-type' bit. */
2103 TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
2104 && TREE_CODE (arg
) != TEMPLATE_DECL
2105 /* This next line is the `argument expression is not just a
2106 simple identifier' condition and also the `specialized
2107 non-type argument' bit. */
2108 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
)
2110 if (tpd
.arg_uses_template_parms
[i
])
2111 cp_error ("template argument `%E' involves template parameter(s)", arg
);
2114 /* Look at the corresponding template parameter,
2115 marking which template parameters its type depends
2118 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms
,
2123 /* We haven't yet initialized TPD2. Do so now. */
2124 tpd2
.arg_uses_template_parms
2125 = (int*) alloca (sizeof (int) * nargs
);
2126 /* The number of parameters here is the number in the
2127 main template, which, as checked in the assertion
2129 tpd2
.parms
= (int*) alloca (sizeof (int) * nargs
);
2131 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
2134 /* Mark the template parameters. But this time, we're
2135 looking for the template parameters of the main
2136 template, not in the specialization. */
2137 tpd2
.current_arg
= i
;
2138 tpd2
.arg_uses_template_parms
[i
] = 0;
2139 bzero ((PTR
) tpd2
.parms
, sizeof (int) * nargs
);
2140 for_each_template_parm (type
,
2141 &mark_template_parm
,
2144 if (tpd2
.arg_uses_template_parms
[i
])
2146 /* The type depended on some template parameters.
2147 If they are fully specialized in the
2148 specialization, that's OK. */
2150 for (j
= 0; j
< nargs
; ++j
)
2151 if (tpd2
.parms
[j
] != 0
2152 && tpd
.arg_uses_template_parms
[j
])
2154 cp_error ("type `%T' of template argument `%E' depends on template parameter(s)",
2164 if (retrieve_specialization (maintmpl
, specargs
))
2165 /* We've already got this specialization. */
2168 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
) = CLASSTYPE_TI_SPEC_INFO (type
)
2169 = tree_cons (inner_args
, inner_parms
,
2170 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
2171 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
2175 /* Check that a template declaration's use of default arguments is not
2176 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2177 non-zero if DECL is the thing declared by a primary template.
2178 IS_PARTIAL is non-zero if DECL is a partial specialization. */
2181 check_default_tmpl_args (decl
, parms
, is_primary
, is_partial
)
2188 int last_level_to_check
;
2193 A default template-argument shall not be specified in a
2194 function template declaration or a function template definition, nor
2195 in the template-parameter-list of the definition of a member of a
2198 if (TREE_CODE (DECL_REAL_CONTEXT (decl
)) == FUNCTION_DECL
)
2199 /* You can't have a function template declaration in a local
2200 scope, nor you can you define a member of a class template in a
2204 if (current_class_type
2205 && !TYPE_BEING_DEFINED (current_class_type
)
2206 && DECL_LANG_SPECIFIC (decl
)
2207 /* If this is either a friend defined in the scope of the class
2208 or a member function. */
2209 && DECL_CLASS_CONTEXT (decl
) == current_class_type
2210 /* And, if it was a member function, it really was defined in
2211 the scope of the class. */
2212 && (!DECL_FUNCTION_MEMBER_P (decl
) || DECL_DEFINED_IN_CLASS_P (decl
)))
2213 /* We already checked these parameters when the template was
2214 declared, so there's no need to do it again now. This function
2215 was defined in class scope, but we're processing it's body now
2216 that the class is complete. */
2221 If a template-parameter has a default template-argument, all
2222 subsequent template-parameters shall have a default
2223 template-argument supplied. */
2224 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
2226 tree inner_parms
= TREE_VALUE (parm_level
);
2227 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
2228 int seen_def_arg_p
= 0;
2231 for (i
= 0; i
< ntparms
; ++i
)
2233 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
2234 if (TREE_PURPOSE (parm
))
2236 else if (seen_def_arg_p
)
2238 cp_error ("no default argument for `%D'", TREE_VALUE (parm
));
2239 /* For better subsequent error-recovery, we indicate that
2240 there should have been a default argument. */
2241 TREE_PURPOSE (parm
) = error_mark_node
;
2246 if (TREE_CODE (decl
) != TYPE_DECL
|| is_partial
|| !is_primary
)
2247 /* For an ordinary class template, default template arguments are
2248 allowed at the innermost level, e.g.:
2249 template <class T = int>
2251 but, in a partial specialization, they're not allowed even
2252 there, as we have in [temp.class.spec]:
2254 The template parameter list of a specialization shall not
2255 contain default template argument values.
2257 So, for a partial specialization, or for a function template,
2258 we look at all of them. */
2261 /* But, for a primary class template that is not a partial
2262 specialization we look at all template parameters except the
2264 parms
= TREE_CHAIN (parms
);
2266 /* Figure out what error message to issue. */
2267 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2268 msg
= "default argument for template parameter in function template `%D'";
2269 else if (is_partial
)
2270 msg
= "default argument in partial specialization `%D'";
2272 msg
= "default argument for template parameter for class enclosing `%D'";
2274 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
2275 /* If we're inside a class definition, there's no need to
2276 examine the parameters to the class itself. On the one
2277 hand, they will be checked when the class is defined, and,
2278 on the other, default arguments are legal in things like:
2279 template <class T = double>
2280 struct S { template <class U> void f(U); };
2281 Here the default argument for `S' has no bearing on the
2282 declaration of `f'. */
2283 last_level_to_check
= template_class_depth (current_class_type
) + 1;
2285 /* Check everything. */
2286 last_level_to_check
= 0;
2288 for (parm_level
= parms
;
2289 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
2290 parm_level
= TREE_CHAIN (parm_level
))
2292 tree inner_parms
= TREE_VALUE (parm_level
);
2296 ntparms
= TREE_VEC_LENGTH (inner_parms
);
2297 for (i
= 0; i
< ntparms
; ++i
)
2298 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
2302 cp_error (msg
, decl
);
2306 /* Clear out the default argument so that we are not
2308 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
2311 /* At this point, if we're still interested in issuing messages,
2312 they must apply to classes surrounding the object declared. */
2314 msg
= "default argument for template parameter for class enclosing `%D'";
2318 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2319 parameters given by current_template_args, or reuses a
2320 previously existing one, if appropriate. Returns the DECL, or an
2321 equivalent one, if it is replaced via a call to duplicate_decls.
2323 If IS_FRIEND is non-zero, DECL is a friend declaration. */
2326 push_template_decl_real (decl
, is_friend
)
2336 int new_template_p
= 0;
2338 /* See if this is a partial specialization. */
2339 is_partial
= (DECL_IMPLICIT_TYPEDEF_P (decl
)
2340 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
2341 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)));
2343 is_friend
|= (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
));
2346 /* For a friend, we want the context of the friend function, not
2347 the type of which it is a friend. */
2348 ctx
= DECL_CONTEXT (decl
);
2349 else if (DECL_REAL_CONTEXT (decl
)
2350 && TREE_CODE (DECL_REAL_CONTEXT (decl
)) != NAMESPACE_DECL
)
2351 /* In the case of a virtual function, we want the class in which
2353 ctx
= DECL_REAL_CONTEXT (decl
);
2355 /* Otherwise, if we're currently definining some class, the DECL
2356 is assumed to be a member of the class. */
2357 ctx
= current_scope ();
2359 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
2362 if (!DECL_CONTEXT (decl
))
2363 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
2365 /* See if this is a primary template. */
2366 primary
= pseudo_global_level_p ();
2370 if (current_lang_name
== lang_name_c
)
2371 cp_error ("template with C linkage");
2372 else if (TREE_CODE (decl
) == TYPE_DECL
2373 && ANON_AGGRNAME_P (DECL_NAME (decl
)))
2374 cp_error ("template class without a name");
2375 else if ((DECL_IMPLICIT_TYPEDEF_P (decl
)
2376 && CLASS_TYPE_P (TREE_TYPE (decl
)))
2377 || (TREE_CODE (decl
) == VAR_DECL
&& ctx
&& CLASS_TYPE_P (ctx
))
2378 || TREE_CODE (decl
) == FUNCTION_DECL
)
2381 cp_error ("template declaration of `%#D'", decl
);
2384 /* Check to see that the rules regarding the use of default
2385 arguments are not being violated. */
2386 check_default_tmpl_args (decl
, current_template_parms
,
2387 primary
, is_partial
);
2390 return process_partial_specialization (decl
);
2392 args
= current_template_args ();
2395 || TREE_CODE (ctx
) == FUNCTION_DECL
2396 || TYPE_BEING_DEFINED (ctx
)
2397 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
2399 if (DECL_LANG_SPECIFIC (decl
)
2400 && DECL_TEMPLATE_INFO (decl
)
2401 && DECL_TI_TEMPLATE (decl
))
2402 tmpl
= DECL_TI_TEMPLATE (decl
);
2403 /* If DECL is a TYPE_DECL for a class-template, then there won't
2404 be DECL_LANG_SPECIFIC. The information equivalent to
2405 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2406 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
2407 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
2408 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
2410 /* Since a template declaration already existed for this
2411 class-type, we must be redeclaring it here. Make sure
2412 that the redeclaration is legal. */
2413 redeclare_class_template (TREE_TYPE (decl
),
2414 current_template_parms
);
2415 /* We don't need to create a new TEMPLATE_DECL; just use the
2416 one we already had. */
2417 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
2421 tmpl
= build_template_decl (decl
, current_template_parms
);
2424 if (DECL_LANG_SPECIFIC (decl
)
2425 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2427 /* A specialization of a member template of a template
2429 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
2430 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
2431 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
2437 tree a
, t
, current
, parms
;
2440 if (CLASSTYPE_TEMPLATE_INSTANTIATION (ctx
))
2441 cp_error ("must specialize `%#T' before defining member `%#D'",
2443 if (TREE_CODE (decl
) == TYPE_DECL
)
2445 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl
)))
2446 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2447 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
2448 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
2449 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
2452 cp_error ("`%D' does not declare a template type", decl
);
2456 else if (! DECL_TEMPLATE_INFO (decl
))
2458 cp_error ("template definition of non-template `%#D'", decl
);
2462 tmpl
= DECL_TI_TEMPLATE (decl
);
2464 if (is_member_template (tmpl
)
2465 && DECL_FUNCTION_TEMPLATE_P (tmpl
)
2466 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
2467 && DECL_TEMPLATE_SPECIALIZATION (decl
))
2471 /* The declaration is a specialization of a member
2472 template, declared outside the class. Therefore, the
2473 innermost template arguments will be NULL, so we
2474 replace them with the arguments determined by the
2475 earlier call to check_explicit_specialization. */
2476 args
= DECL_TI_ARGS (decl
);
2479 = build_template_decl (decl
, current_template_parms
);
2480 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
2481 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
2482 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
2483 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
2484 DECL_TEMPLATE_INFO (new_tmpl
)
2485 = tree_cons (tmpl
, args
, NULL_TREE
);
2487 register_specialization (new_tmpl
, tmpl
, args
);
2491 /* Make sure the template headers we got make sense. */
2493 parms
= DECL_TEMPLATE_PARMS (tmpl
);
2494 i
= TMPL_PARMS_DEPTH (parms
);
2495 if (TMPL_ARGS_DEPTH (args
) != i
)
2497 cp_error ("expected %d levels of template parms for `%#D', got %d",
2498 i
, decl
, TMPL_ARGS_DEPTH (args
));
2501 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
2503 a
= TMPL_ARGS_LEVEL (args
, i
);
2504 t
= INNERMOST_TEMPLATE_PARMS (parms
);
2506 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
2508 if (current
== decl
)
2509 cp_error ("got %d template parameters for `%#D'",
2510 TREE_VEC_LENGTH (a
), decl
);
2512 cp_error ("got %d template parameters for `%#T'",
2513 TREE_VEC_LENGTH (a
), current
);
2514 cp_error (" but %d required", TREE_VEC_LENGTH (t
));
2517 /* Perhaps we should also check that the parms are used in the
2518 appropriate qualifying scopes in the declarator? */
2520 if (current
== decl
)
2523 current
= TYPE_CONTEXT (current
);
2527 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
2528 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
2530 /* Push template declarations for global functions and types. Note
2531 that we do not try to push a global template friend declared in a
2532 template class; such a thing may well depend on the template
2533 parameters of the class. */
2534 if (new_template_p
&& !ctx
2535 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
2536 tmpl
= pushdecl_namespace_level (tmpl
);
2539 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
2541 info
= tree_cons (tmpl
, args
, NULL_TREE
);
2543 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
2545 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
2546 if ((!ctx
|| TREE_CODE (ctx
) != FUNCTION_DECL
)
2547 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
)
2548 DECL_NAME (decl
) = classtype_mangled_name (TREE_TYPE (decl
));
2550 else if (DECL_LANG_SPECIFIC (decl
))
2551 DECL_TEMPLATE_INFO (decl
) = info
;
2553 return DECL_TEMPLATE_RESULT (tmpl
);
2557 push_template_decl (decl
)
2560 return push_template_decl_real (decl
, 0);
2563 /* Called when a class template TYPE is redeclared with the indicated
2564 template PARMS, e.g.:
2566 template <class T> struct S;
2567 template <class T> struct S {}; */
2570 redeclare_class_template (type
, parms
)
2578 if (!TYPE_TEMPLATE_INFO (type
))
2580 cp_error ("`%T' is not a template type", type
);
2584 tmpl
= TYPE_TI_TEMPLATE (type
);
2585 if (!PRIMARY_TEMPLATE_P (tmpl
))
2586 /* The type is nested in some template class. Nothing to worry
2587 about here; there are no new template parameters for the nested
2591 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
2592 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
2594 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
2596 cp_error_at ("previous declaration `%D'", tmpl
);
2597 cp_error ("used %d template parameter%s instead of %d",
2598 TREE_VEC_LENGTH (tmpl_parms
),
2599 TREE_VEC_LENGTH (tmpl_parms
) == 1 ? "" : "s",
2600 TREE_VEC_LENGTH (parms
));
2604 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
2606 tree tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
2607 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
2608 tree tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
2609 tree parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
2611 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
))
2613 cp_error_at ("template parameter `%#D'", tmpl_parm
);
2614 cp_error ("redeclared here as `%#D'", parm
);
2618 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
2620 /* We have in [temp.param]:
2622 A template-parameter may not be given default arguments
2623 by two different declarations in the same scope. */
2624 cp_error ("redefinition of default argument for `%#D'", parm
);
2625 cp_error_at (" original definition appeared here", tmpl_parm
);
2629 if (parm_default
!= NULL_TREE
)
2630 /* Update the previous template parameters (which are the ones
2631 that will really count) with the new default value. */
2632 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
2633 else if (tmpl_default
!= NULL_TREE
)
2634 /* Update the new parameters, too; they'll be used as the
2635 parameters for any members. */
2636 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
2640 /* Attempt to convert the non-type template parameter EXPR to the
2641 indicated TYPE. If the conversion is successful, return the
2642 converted value. If the conversion is unsuccesful, return
2643 NULL_TREE if we issued an error message, or error_mark_node if we
2644 did not. We issue error messages for out-and-out bad template
2645 parameters, but not simply because the conversion failed, since we
2646 might be just trying to do argument deduction. By the time this
2647 function is called, neither TYPE nor EXPR may make use of template
2651 convert_nontype_argument (type
, expr
)
2655 tree expr_type
= TREE_TYPE (expr
);
2657 /* A template-argument for a non-type, non-template
2658 template-parameter shall be one of:
2660 --an integral constant-expression of integral or enumeration
2663 --the name of a non-type template-parameter; or
2665 --the name of an object or function with external linkage,
2666 including function templates and function template-ids but
2667 excluding non-static class members, expressed as id-expression;
2670 --the address of an object or function with external linkage,
2671 including function templates and function template-ids but
2672 excluding non-static class members, expressed as & id-expression
2673 where the & is optional if the name refers to a function or
2676 --a pointer to member expressed as described in _expr.unary.op_. */
2678 /* An integral constant-expression can include const variables or
2679 enumerators. Simplify things by folding them to their values,
2680 unless we're about to bind the declaration to a reference
2682 if (INTEGRAL_TYPE_P (expr_type
) && TREE_READONLY_DECL_P (expr
)
2683 && TREE_CODE (type
) != REFERENCE_TYPE
)
2684 expr
= decl_constant_value (expr
);
2686 if (is_overloaded_fn (expr
))
2687 /* OK for now. We'll check that it has external linkage later.
2688 Check this first since if expr_type is the unknown_type_node
2689 we would otherwise complain below. */
2691 else if (TYPE_PTRMEM_P (expr_type
)
2692 || TYPE_PTRMEMFUNC_P (expr_type
))
2694 if (TREE_CODE (expr
) != PTRMEM_CST
)
2697 else if (TYPE_PTR_P (expr_type
)
2698 || TYPE_PTRMEM_P (expr_type
)
2699 || TREE_CODE (expr_type
) == ARRAY_TYPE
2700 || TREE_CODE (type
) == REFERENCE_TYPE
2701 /* If expr is the address of an overloaded function, we
2702 will get the unknown_type_node at this point. */
2703 || expr_type
== unknown_type_node
)
2709 if (TREE_CODE (type
) == REFERENCE_TYPE
2710 || TREE_CODE (expr_type
) == ARRAY_TYPE
)
2714 if (TREE_CODE (e
) != ADDR_EXPR
)
2717 cp_error ("`%E' is not a valid template argument", expr
);
2718 if (TYPE_PTR_P (expr_type
))
2720 if (TREE_CODE (TREE_TYPE (expr_type
)) == FUNCTION_TYPE
)
2721 cp_error ("it must be the address of a function with external linkage");
2723 cp_error ("it must be the address of an object with external linkage");
2725 else if (TYPE_PTRMEM_P (expr_type
)
2726 || TYPE_PTRMEMFUNC_P (expr_type
))
2727 cp_error ("it must be a pointer-to-member of the form `&X::Y'");
2732 referent
= TREE_OPERAND (e
, 0);
2733 STRIP_NOPS (referent
);
2736 if (TREE_CODE (referent
) == STRING_CST
)
2738 cp_error ("string literal %E is not a valid template argument",
2740 error ("because it is the address of an object with static linkage");
2744 if (is_overloaded_fn (referent
))
2745 /* We'll check that it has external linkage later. */
2747 else if (TREE_CODE (referent
) != VAR_DECL
)
2749 else if (!TREE_PUBLIC (referent
))
2751 cp_error ("address of non-extern `%E' cannot be used as template argument", referent
);
2752 return error_mark_node
;
2755 else if (INTEGRAL_TYPE_P (expr_type
)
2756 || TYPE_PTRMEM_P (expr_type
)
2757 || TYPE_PTRMEMFUNC_P (expr_type
)
2758 /* The next two are g++ extensions. */
2759 || TREE_CODE (expr_type
) == REAL_TYPE
2760 || TREE_CODE (expr_type
) == COMPLEX_TYPE
)
2762 if (! TREE_CONSTANT (expr
))
2765 cp_error ("non-constant `%E' cannot be used as template argument",
2772 cp_error ("object `%E' cannot be used as template argument", expr
);
2776 switch (TREE_CODE (type
))
2781 /* For a non-type template-parameter of integral or enumeration
2782 type, integral promotions (_conv.prom_) and integral
2783 conversions (_conv.integral_) are applied. */
2784 if (!INTEGRAL_TYPE_P (expr_type
))
2785 return error_mark_node
;
2787 /* It's safe to call digest_init in this case; we know we're
2788 just converting one integral constant expression to another. */
2789 expr
= digest_init (type
, expr
, (tree
*) 0);
2791 if (TREE_CODE (expr
) != INTEGER_CST
)
2792 /* Curiously, some TREE_CONSTANT integral expressions do not
2793 simplify to integer constants. For example, `3 % 0',
2794 remains a TRUNC_MOD_EXPR. */
2801 /* These are g++ extensions. */
2802 if (TREE_CODE (expr_type
) != TREE_CODE (type
))
2803 return error_mark_node
;
2805 expr
= digest_init (type
, expr
, (tree
*) 0);
2807 if (TREE_CODE (expr
) != REAL_CST
)
2814 tree type_pointed_to
= TREE_TYPE (type
);
2816 if (TYPE_PTRMEM_P (type
))
2820 /* For a non-type template-parameter of type pointer to data
2821 member, qualification conversions (_conv.qual_) are
2823 e
= perform_qualification_conversions (type
, expr
);
2824 if (TREE_CODE (e
) == NOP_EXPR
)
2825 /* The call to perform_qualification_conversions will
2826 insert a NOP_EXPR over EXPR to do express conversion,
2827 if necessary. But, that will confuse us if we use
2828 this (converted) template parameter to instantiate
2829 another template; then the thing will not look like a
2830 valid template argument. So, just make a new
2831 constant, of the appropriate type. */
2832 e
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
2835 else if (TREE_CODE (type_pointed_to
) == FUNCTION_TYPE
)
2837 /* For a non-type template-parameter of type pointer to
2838 function, only the function-to-pointer conversion
2839 (_conv.func_) is applied. If the template-argument
2840 represents a set of overloaded functions (or a pointer to
2841 such), the matching function is selected from the set
2846 if (TREE_CODE (expr
) == ADDR_EXPR
)
2847 fns
= TREE_OPERAND (expr
, 0);
2851 fn
= instantiate_type (type_pointed_to
, fns
, 0);
2853 if (fn
== error_mark_node
)
2854 return error_mark_node
;
2856 if (!TREE_PUBLIC (fn
))
2858 if (really_overloaded_fn (fns
))
2859 return error_mark_node
;
2864 expr
= build_unary_op (ADDR_EXPR
, fn
, 0);
2866 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2872 /* For a non-type template-parameter of type pointer to
2873 object, qualification conversions (_conv.qual_) and the
2874 array-to-pointer conversion (_conv.array_) are applied.
2875 [Note: In particular, neither the null pointer conversion
2876 (_conv.ptr_) nor the derived-to-base conversion
2877 (_conv.ptr_) are applied. Although 0 is a valid
2878 template-argument for a non-type template-parameter of
2879 integral type, it is not a valid template-argument for a
2880 non-type template-parameter of pointer type.]
2882 The call to decay_conversion performs the
2883 array-to-pointer conversion, if appropriate. */
2884 expr
= decay_conversion (expr
);
2886 if (expr
== error_mark_node
)
2887 return error_mark_node
;
2889 return perform_qualification_conversions (type
, expr
);
2894 case REFERENCE_TYPE
:
2896 tree type_referred_to
= TREE_TYPE (type
);
2898 if (TREE_CODE (type_referred_to
) == FUNCTION_TYPE
)
2900 /* For a non-type template-parameter of type reference to
2901 function, no conversions apply. If the
2902 template-argument represents a set of overloaded
2903 functions, the matching function is selected from the
2904 set (_over.over_). */
2908 fn
= instantiate_type (type_referred_to
, fns
, 0);
2910 if (fn
== error_mark_node
)
2911 return error_mark_node
;
2913 if (!TREE_PUBLIC (fn
))
2915 if (really_overloaded_fn (fns
))
2916 /* Don't issue an error here; we might get a different
2917 function if the overloading had worked out
2919 return error_mark_node
;
2924 my_friendly_assert (same_type_p (type_referred_to
,
2932 /* For a non-type template-parameter of type reference to
2933 object, no conversions apply. The type referred to by the
2934 reference may be more cv-qualified than the (otherwise
2935 identical) type of the template-argument. The
2936 template-parameter is bound directly to the
2937 template-argument, which must be an lvalue. */
2938 if ((TYPE_MAIN_VARIANT (expr_type
)
2939 != TYPE_MAIN_VARIANT (type_referred_to
))
2940 || !at_least_as_qualified_p (type_referred_to
,
2942 || !real_lvalue_p (expr
))
2943 return error_mark_node
;
2952 if (!TYPE_PTRMEMFUNC_P (type
))
2953 /* This handles templates like
2954 template<class T, T t> void f();
2955 when T is substituted with any class. The second template
2956 parameter becomes invalid and the template candidate is
2958 return error_mark_node
;
2960 /* For a non-type template-parameter of type pointer to member
2961 function, no conversions apply. If the template-argument
2962 represents a set of overloaded member functions, the
2963 matching member function is selected from the set
2966 if (!TYPE_PTRMEMFUNC_P (expr_type
) &&
2967 expr_type
!= unknown_type_node
)
2968 return error_mark_node
;
2970 if (TREE_CODE (expr
) == PTRMEM_CST
)
2972 /* A ptr-to-member constant. */
2973 if (!same_type_p (type
, expr_type
))
2974 return error_mark_node
;
2979 if (TREE_CODE (expr
) != ADDR_EXPR
)
2980 return error_mark_node
;
2982 expr
= instantiate_type (type
, expr
, 0);
2984 if (expr
== error_mark_node
)
2985 return error_mark_node
;
2987 my_friendly_assert (same_type_p (type
, TREE_TYPE (expr
)),
2994 /* All non-type parameters must have one of these types. */
2995 my_friendly_abort (0);
2999 return error_mark_node
;
3002 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3003 template template parameters. Both PARM_PARMS and ARG_PARMS are
3004 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3007 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3008 the case, then extra parameters must have default arguments.
3010 Consider the example:
3011 template <class T, class Allocator = allocator> class vector;
3012 template<template <class U> class TT> class C;
3014 C<vector> is a valid instantiation. PARM_PARMS for the above code
3015 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3016 T and Allocator) and OUTER_ARGS contains the argument that is used to
3017 substitute the TT parameter. */
3020 coerce_template_template_parms (parm_parms
, arg_parms
, complain
,
3021 in_decl
, outer_args
)
3022 tree parm_parms
, arg_parms
;
3024 tree in_decl
, outer_args
;
3026 int nparms
, nargs
, i
;
3029 my_friendly_assert (TREE_CODE (parm_parms
) == TREE_VEC
, 0);
3030 my_friendly_assert (TREE_CODE (arg_parms
) == TREE_VEC
, 0);
3032 nparms
= TREE_VEC_LENGTH (parm_parms
);
3033 nargs
= TREE_VEC_LENGTH (arg_parms
);
3035 /* The rule here is opposite of coerce_template_parms. */
3038 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms
, nparms
)) == NULL_TREE
))
3041 for (i
= 0; i
< nparms
; ++i
)
3043 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
3044 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
3046 if (arg
== NULL_TREE
|| arg
== error_mark_node
3047 || parm
== NULL_TREE
|| parm
== error_mark_node
)
3050 if (TREE_CODE (arg
) != TREE_CODE (parm
))
3053 switch (TREE_CODE (parm
))
3059 /* We encounter instantiations of templates like
3060 template <template <template <class> class> class TT>
3063 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
3064 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
3066 if (!coerce_template_template_parms (parmparm
, argparm
,
3074 /* The tsubst call is used to handle cases such as
3075 template <class T, template <T> class TT> class D;
3076 i.e. the parameter list of TT depends on earlier parameters. */
3077 if (!same_type_p (tsubst (TREE_TYPE (parm
), outer_args
,
3084 my_friendly_abort (0);
3090 /* Convert the indicated template ARG as necessary to match the
3091 indicated template PARM. Returns the converted ARG, or
3092 error_mark_node if the conversion was unsuccessful. Error messages
3093 are issued if COMPLAIN is non-zero. This conversion is for the Ith
3094 parameter in the parameter list. ARGS is the full set of template
3095 arguments deduced so far. */
3098 convert_template_argument (parm
, arg
, args
, complain
, i
, in_decl
)
3108 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
3110 inner_args
= innermost_args (args
);
3112 if (TREE_CODE (arg
) == TREE_LIST
3113 && TREE_TYPE (arg
) != NULL_TREE
3114 && TREE_CODE (TREE_TYPE (arg
)) == OFFSET_TYPE
)
3116 /* The template argument was the name of some
3117 member function. That's usually
3118 illegal, but static members are OK. In any
3119 case, grab the underlying fields/functions
3120 and issue an error later if required. */
3121 arg
= TREE_VALUE (arg
);
3122 TREE_TYPE (arg
) = unknown_type_node
;
3125 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
3126 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
3127 || requires_tmpl_type
);
3129 /* Check if it is a class template. If REQUIRES_TMPL_TYPE is true,
3130 we also accept implicitly created TYPE_DECL as a valid argument.
3131 This is necessary to handle the case where we pass a template name
3132 to a template template parameter in a scope where we've derived from
3133 in instantiation of that template, so the template name refers to that
3134 instantiation. We really ought to handle this better. */
3136 = ((TREE_CODE (arg
) == TEMPLATE_DECL
3137 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
3138 || (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
3139 && !TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (arg
))
3140 || (TREE_CODE (arg
) == RECORD_TYPE
3141 && CLASSTYPE_TEMPLATE_INFO (arg
)
3142 && TREE_CODE (TYPE_NAME (arg
)) == TYPE_DECL
3143 && DECL_ARTIFICIAL (TYPE_NAME (arg
))
3144 && requires_tmpl_type
3145 && is_base_of_enclosing_class (arg
, current_class_type
)));
3146 if (is_tmpl_type
&& TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
3147 arg
= TYPE_STUB_DECL (arg
);
3148 else if (is_tmpl_type
&& TREE_CODE (arg
) == RECORD_TYPE
)
3149 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
3151 is_type
= TREE_CODE_CLASS (TREE_CODE (arg
)) == 't' || is_tmpl_type
;
3153 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
3154 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
3156 cp_pedwarn ("to refer to a type member of a template parameter,");
3157 cp_pedwarn (" use `typename %E'", arg
);
3159 arg
= make_typename_type (TREE_OPERAND (arg
, 0),
3160 TREE_OPERAND (arg
, 1),
3164 if (is_type
!= requires_type
)
3170 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3173 cp_error (" expected a constant of type `%T', got `%T'",
3175 (is_tmpl_type
? DECL_NAME (arg
) : arg
));
3177 cp_error (" expected a type, got `%E'", arg
);
3180 return error_mark_node
;
3182 if (is_tmpl_type
^ requires_tmpl_type
)
3184 if (in_decl
&& complain
)
3186 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3189 cp_error (" expected a type, got `%T'", DECL_NAME (arg
));
3191 cp_error (" expected a class template, got `%T'", arg
);
3193 return error_mark_node
;
3198 if (requires_tmpl_type
)
3200 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
3201 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
3203 if (coerce_template_template_parms (parmparm
, argparm
, complain
,
3204 in_decl
, inner_args
))
3208 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3210 if (val
!= error_mark_node
3211 && DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
3212 val
= TREE_TYPE (val
);
3216 if (in_decl
&& complain
)
3218 cp_error ("type/value mismatch at argument %d in template parameter list for `%D'",
3220 cp_error (" expected a template of type `%D', got `%D'", parm
, arg
);
3223 val
= error_mark_node
;
3228 val
= groktypename (arg
);
3229 if (! processing_template_decl
)
3231 /* [basic.link]: A name with no linkage (notably, the
3232 name of a class or enumeration declared in a local
3233 scope) shall not be used to declare an entity with
3234 linkage. This implies that names with no linkage
3235 cannot be used as template arguments. */
3236 tree t
= no_linkage_check (val
);
3239 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
3241 ("template-argument `%T' uses anonymous type", val
);
3244 ("template-argument `%T' uses local type `%T'",
3246 return error_mark_node
;
3253 tree t
= tsubst (TREE_TYPE (parm
), args
, complain
, in_decl
);
3255 if (processing_template_decl
)
3256 arg
= maybe_fold_nontype_arg (arg
);
3258 if (!uses_template_parms (arg
) && !uses_template_parms (t
))
3259 /* We used to call digest_init here. However, digest_init
3260 will report errors, which we don't want when complain
3261 is zero. More importantly, digest_init will try too
3262 hard to convert things: for example, `0' should not be
3263 converted to pointer type at this point according to
3264 the standard. Accepting this is not merely an
3265 extension, since deciding whether or not these
3266 conversions can occur is part of determining which
3267 function template to call, or whether a given epxlicit
3268 argument specification is legal. */
3269 val
= convert_nontype_argument (t
, arg
);
3273 if (val
== NULL_TREE
)
3274 val
= error_mark_node
;
3275 else if (val
== error_mark_node
&& complain
)
3276 cp_error ("could not convert template argument `%E' to `%T'",
3283 /* Convert all template arguments to their appropriate types, and
3284 return a vector containing the innermost resulting template
3285 arguments. If any error occurs, return error_mark_node, and, if
3286 COMPLAIN is non-zero, issue an error message. Some error messages
3287 are issued even if COMPLAIN is zero; for instance, if a template
3288 argument is composed from a local class.
3290 If REQUIRE_ALL_ARGUMENTS is non-zero, all arguments must be
3291 provided in ARGLIST, or else trailing parameters must have default
3292 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3293 deduction for any unspecified trailing arguments.
3295 The resulting TREE_VEC is allocated on a temporary obstack, and
3296 must be explicitly copied if it will be permanent. */
3299 coerce_template_parms (parms
, args
, in_decl
,
3301 require_all_arguments
)
3305 int require_all_arguments
;
3307 int nparms
, nargs
, i
, lost
= 0;
3310 tree new_inner_args
;
3312 inner_args
= innermost_args (args
);
3313 nargs
= NUM_TMPL_ARGS (inner_args
);
3314 nparms
= TREE_VEC_LENGTH (parms
);
3318 && require_all_arguments
3319 && TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
)) == NULL_TREE
))
3323 cp_error ("wrong number of template arguments (%d, should be %d)",
3327 cp_error_at ("provided for `%D'", in_decl
);
3330 return error_mark_node
;
3333 new_inner_args
= make_tree_vec (nparms
);
3334 new_args
= add_outermost_template_args (args
, new_inner_args
);
3335 for (i
= 0; i
< nparms
; i
++)
3340 /* Get the Ith template parameter. */
3341 parm
= TREE_VEC_ELT (parms
, i
);
3343 /* Calculate the Ith argument. */
3344 if (inner_args
&& TREE_CODE (inner_args
) == TREE_LIST
)
3346 arg
= TREE_VALUE (inner_args
);
3347 inner_args
= TREE_CHAIN (inner_args
);
3350 arg
= TREE_VEC_ELT (inner_args
, i
);
3351 /* If no template argument was supplied, look for a default
3353 else if (TREE_PURPOSE (parm
) == NULL_TREE
)
3355 /* There was no default value. */
3356 my_friendly_assert (!require_all_arguments
, 0);
3359 else if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
)
3360 arg
= tsubst (TREE_PURPOSE (parm
), new_args
, complain
, in_decl
);
3362 arg
= tsubst_expr (TREE_PURPOSE (parm
), new_args
, complain
,
3365 /* Now, convert the Ith argument, as necessary. */
3366 if (arg
== NULL_TREE
)
3367 /* We're out of arguments. */
3369 my_friendly_assert (!require_all_arguments
, 0);
3372 else if (arg
== error_mark_node
)
3374 cp_error ("template argument %d is invalid", i
+ 1);
3375 arg
= error_mark_node
;
3378 arg
= convert_template_argument (TREE_VALUE (parm
),
3379 arg
, new_args
, complain
, i
,
3382 if (arg
== error_mark_node
)
3384 TREE_VEC_ELT (new_inner_args
, i
) = arg
;
3388 return error_mark_node
;
3390 return new_inner_args
;
3393 /* Returns 1 if template args OT and NT are equivalent. */
3396 template_args_equal (ot
, nt
)
3401 if (TREE_CODE (nt
) != TREE_CODE (ot
))
3403 if (TREE_CODE (nt
) == TREE_VEC
)
3404 /* For member templates */
3405 return comp_template_args (ot
, nt
);
3406 else if (TREE_CODE_CLASS (TREE_CODE (ot
)) == 't')
3407 return same_type_p (ot
, nt
);
3409 return (cp_tree_equal (ot
, nt
) > 0);
3412 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3413 of template arguments. Returns 0 otherwise. */
3416 comp_template_args (oldargs
, newargs
)
3417 tree oldargs
, newargs
;
3421 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
3424 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
3426 tree nt
= TREE_VEC_ELT (newargs
, i
);
3427 tree ot
= TREE_VEC_ELT (oldargs
, i
);
3429 if (! template_args_equal (ot
, nt
))
3435 /* Given class template name and parameter list, produce a user-friendly name
3436 for the instantiation. */
3439 mangle_class_name_for_template (name
, parms
, arglist
)
3441 tree parms
, arglist
;
3443 static struct obstack scratch_obstack
;
3444 static char *scratch_firstobj
;
3447 if (!scratch_firstobj
)
3448 gcc_obstack_init (&scratch_obstack
);
3450 obstack_free (&scratch_obstack
, scratch_firstobj
);
3451 scratch_firstobj
= obstack_alloc (&scratch_obstack
, 1);
3453 #define ccat(c) obstack_1grow (&scratch_obstack, (c));
3454 #define cat(s) obstack_grow (&scratch_obstack, (s), strlen (s))
3458 nparms
= TREE_VEC_LENGTH (parms
);
3459 arglist
= innermost_args (arglist
);
3460 my_friendly_assert (nparms
== TREE_VEC_LENGTH (arglist
), 268);
3461 for (i
= 0; i
< nparms
; i
++)
3463 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
3464 tree arg
= TREE_VEC_ELT (arglist
, i
);
3469 if (TREE_CODE (parm
) == TYPE_DECL
)
3471 cat (type_as_string (arg
, TS_CHASE_TYPEDEFS
));
3474 else if (TREE_CODE (parm
) == TEMPLATE_DECL
)
3476 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
3478 /* Already substituted with real template. Just output
3479 the template name here */
3480 tree context
= DECL_CONTEXT (arg
);
3483 /* The template may be defined in a namespace, or
3484 may be a member template. */
3485 my_friendly_assert (TREE_CODE (context
) == NAMESPACE_DECL
3486 || CLASS_TYPE_P (context
),
3488 cat(decl_as_string (DECL_CONTEXT (arg
), 0));
3491 cat (IDENTIFIER_POINTER (DECL_NAME (arg
)));
3494 /* Output the parameter declaration */
3495 cat (type_as_string (arg
, TS_CHASE_TYPEDEFS
));
3499 my_friendly_assert (TREE_CODE (parm
) == PARM_DECL
, 269);
3501 if (TREE_CODE (arg
) == TREE_LIST
)
3503 /* New list cell was built because old chain link was in
3505 my_friendly_assert (TREE_PURPOSE (arg
) == NULL_TREE
, 270);
3506 arg
= TREE_VALUE (arg
);
3508 /* No need to check arglist against parmlist here; we did that
3509 in coerce_template_parms, called from lookup_template_class. */
3510 cat (expr_as_string (arg
, 0));
3513 char *bufp
= obstack_next_free (&scratch_obstack
);
3515 while (bufp
[offset
- 1] == ' ')
3517 obstack_blank_fast (&scratch_obstack
, offset
);
3519 /* B<C<char> >, not B<C<char>> */
3520 if (bufp
[offset
- 1] == '>')
3525 return (char *) obstack_base (&scratch_obstack
);
3529 classtype_mangled_name (t
)
3532 if (CLASSTYPE_TEMPLATE_INFO (t
)
3533 /* Specializations have already had their names set up in
3534 lookup_template_class. */
3535 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
3537 tree tmpl
= most_general_template (CLASSTYPE_TI_TEMPLATE (t
));
3539 /* For non-primary templates, the template parameters are
3540 implicit from their surrounding context. */
3541 if (PRIMARY_TEMPLATE_P (tmpl
))
3543 tree name
= DECL_NAME (tmpl
);
3544 char *mangled_name
= mangle_class_name_for_template
3545 (IDENTIFIER_POINTER (name
),
3546 DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
3547 CLASSTYPE_TI_ARGS (t
));
3548 tree id
= get_identifier (mangled_name
);
3549 IDENTIFIER_TEMPLATE (id
) = name
;
3554 return TYPE_IDENTIFIER (t
);
3558 add_pending_template (d
)
3563 if (TREE_CODE_CLASS (TREE_CODE (d
)) == 't')
3564 ti
= CLASSTYPE_TEMPLATE_INFO (d
);
3566 ti
= DECL_TEMPLATE_INFO (d
);
3568 if (TI_PENDING_TEMPLATE_FLAG (ti
))
3571 *template_tail
= tree_cons (build_srcloc_here (), d
, NULL_TREE
);
3572 template_tail
= &TREE_CHAIN (*template_tail
);
3573 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
3577 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS (which
3578 may be either a _DECL or an overloaded function or an
3579 IDENTIFIER_NODE), and ARGLIST. */
3582 lookup_template_function (fns
, arglist
)
3587 if (fns
== NULL_TREE
)
3589 cp_error ("non-template used as template");
3590 return error_mark_node
;
3593 type
= TREE_TYPE (fns
);
3594 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
3595 type
= unknown_type_node
;
3597 if (processing_template_decl
)
3598 return build_min (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3600 return build (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
3603 /* Within the scope of a template class S<T>, the name S gets bound
3604 (in build_self_reference) to a TYPE_DECL for the class, not a
3605 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
3606 or one of its enclosing classes, and that type is a template,
3607 return the associated TEMPLATE_DECL. Otherwise, the original
3608 DECL is returned. */
3611 maybe_get_template_decl_from_type_decl (decl
)
3614 return (decl
!= NULL_TREE
3615 && TREE_CODE (decl
) == TYPE_DECL
3616 && DECL_ARTIFICIAL (decl
)
3617 && CLASS_TYPE_P (TREE_TYPE (decl
))
3618 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
3619 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
3622 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
3623 parameters, find the desired type.
3625 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
3626 (Actually ARGLIST may be either a TREE_LIST or a TREE_VEC. It will
3627 be a TREE_LIST if called directly from the parser, and a TREE_VEC
3628 otherwise.) Since ARGLIST is build on the temp_decl_obstack, we must
3629 copy it here to keep it from being reclaimed when the decl storage
3632 IN_DECL, if non-NULL, is the template declaration we are trying to
3635 If ENTERING_SCOPE is non-zero, we are about to enter the scope of
3636 the class we are looking up.
3638 If the template class is really a local class in a template
3639 function, then the FUNCTION_CONTEXT is the function in which it is
3640 being instantiated. */
3643 lookup_template_class (d1
, arglist
, in_decl
, context
, entering_scope
)
3649 tree
template = NULL_TREE
, parmlist
;
3652 if (TREE_CODE (d1
) == IDENTIFIER_NODE
)
3654 if (IDENTIFIER_VALUE (d1
)
3655 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1
)))
3656 template = IDENTIFIER_VALUE (d1
);
3660 push_decl_namespace (context
);
3661 template = lookup_name (d1
, /*prefer_type=*/0);
3662 template = maybe_get_template_decl_from_type_decl (template);
3664 pop_decl_namespace ();
3667 context
= DECL_CONTEXT (template);
3669 else if (TREE_CODE (d1
) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (d1
)))
3671 tree type
= TREE_TYPE (d1
);
3673 /* If we are declaring a constructor, say A<T>::A<T>, we will get
3674 an implicit typename for the second A. Deal with it. */
3675 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
3676 type
= TREE_TYPE (type
);
3678 if (CLASSTYPE_TEMPLATE_INFO (type
))
3680 template = CLASSTYPE_TI_TEMPLATE (type
);
3681 d1
= DECL_NAME (template);
3684 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
3685 || (TREE_CODE_CLASS (TREE_CODE (d1
)) == 't'
3686 && IS_AGGR_TYPE (d1
)))
3688 template = TYPE_TI_TEMPLATE (d1
);
3689 d1
= DECL_NAME (template);
3691 else if (TREE_CODE (d1
) == TEMPLATE_DECL
3692 && TREE_CODE (DECL_RESULT (d1
)) == TYPE_DECL
)
3695 d1
= DECL_NAME (template);
3696 context
= DECL_CONTEXT (template);
3699 my_friendly_abort (272);
3701 /* With something like `template <class T> class X class X { ... };'
3702 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
3703 We don't want to do that, but we have to deal with the situation,
3704 so let's give them some syntax errors to chew on instead of a
3708 cp_error ("`%T' is not a template", d1
);
3709 return error_mark_node
;
3712 if (context
== NULL_TREE
)
3713 context
= global_namespace
;
3715 if (TREE_CODE (template) != TEMPLATE_DECL
)
3717 cp_error ("non-template type `%T' used as a template", d1
);
3719 cp_error_at ("for template declaration `%D'", in_decl
);
3720 return error_mark_node
;
3723 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
3725 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
3726 template arguments */
3728 tree parm
= copy_template_template_parm (TREE_TYPE (template));
3729 tree template2
= TYPE_STUB_DECL (parm
);
3732 parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (template);
3734 arglist2
= coerce_template_parms (parmlist
, arglist
, template, 1, 1);
3735 if (arglist2
== error_mark_node
)
3736 return error_mark_node
;
3738 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
)
3739 = tree_cons (template2
, arglist2
, NULL_TREE
);
3740 TYPE_SIZE (parm
) = 0;
3745 tree template_type
= TREE_TYPE (template);
3748 tree found
= NULL_TREE
;
3751 int is_partial_instantiation
;
3753 gen_tmpl
= most_general_template (template);
3754 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
3755 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
3756 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3758 if (arg_depth
== 1 && parm_depth
> 1)
3760 /* We've been given an incomplete set of template arguments.
3763 template <class T> struct S1 {
3764 template <class U> struct S2 {};
3765 template <class U> struct S2<U*> {};
3768 we will be called with an ARGLIST of `U*', but the
3769 TEMPLATE will be `template <class T> template
3770 <class U> struct S1<T>::S2'. We must fill in the missing
3773 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
3775 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
3778 /* Now we should enough arguments. */
3779 my_friendly_assert (parm_depth
== arg_depth
, 0);
3781 /* From here on, we're only interested in the most general
3783 template = gen_tmpl
;
3785 /* Calculate the BOUND_ARGS. These will be the args that are
3786 actually tsubst'd into the definition to create the
3790 /* We have multiple levels of arguments to coerce, at once. */
3792 int saved_depth
= TMPL_ARGS_DEPTH (arglist
);
3794 tree bound_args
= make_tree_vec (parm_depth
);
3796 for (i
= saved_depth
,
3797 t
= DECL_TEMPLATE_PARMS (template);
3798 i
> 0 && t
!= NULL_TREE
;
3799 --i
, t
= TREE_CHAIN (t
))
3801 tree a
= coerce_template_parms (TREE_VALUE (t
),
3802 arglist
, template, 1, 1);
3803 SET_TMPL_ARGS_LEVEL (bound_args
, i
, a
);
3805 /* We temporarily reduce the length of the ARGLIST so
3806 that coerce_template_parms will see only the arguments
3807 corresponding to the template parameters it is
3809 TREE_VEC_LENGTH (arglist
)--;
3812 /* Restore the ARGLIST to its full size. */
3813 TREE_VEC_LENGTH (arglist
) = saved_depth
;
3815 arglist
= bound_args
;
3819 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist
),
3820 innermost_args (arglist
),
3823 if (arglist
== error_mark_node
)
3824 /* We were unable to bind the arguments. */
3825 return error_mark_node
;
3827 /* In the scope of a template class, explicit references to the
3828 template class refer to the type of the template, not any
3829 instantiation of it. For example, in:
3831 template <class T> class C { void f(C<T>); }
3833 the `C<T>' is just the same as `C'. Outside of the
3834 class, however, such a reference is an instantiation. */
3835 if (comp_template_args (TYPE_TI_ARGS (template_type
),
3838 found
= template_type
;
3840 if (!entering_scope
&& PRIMARY_TEMPLATE_P (template))
3844 /* Note that we use DECL_CONTEXT, rather than
3845 CP_DECL_CONTEXT, so that the termination test is
3846 always just `ctx'. We're not interested in namepace
3848 for (ctx
= current_class_type
;
3850 ctx
= (TREE_CODE_CLASS (TREE_CODE (ctx
)) == 't')
3851 ? TYPE_CONTEXT (ctx
) : DECL_CONTEXT (ctx
))
3852 if (same_type_p (ctx
, template_type
))
3856 /* We're not in the scope of the class, so the
3857 TEMPLATE_TYPE is not the type we want after
3865 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3866 found
; found
= TREE_CHAIN (found
))
3867 if (comp_template_args (TREE_PURPOSE (found
), arglist
))
3871 found
= TREE_VALUE (found
);
3877 /* This type is a "partial instantiation" if any of the template
3878 arguments still inolve template parameters. Note that we set
3879 IS_PARTIAL_INSTANTIATION for partial specializations as
3881 is_partial_instantiation
= uses_template_parms (arglist
);
3883 if (!is_partial_instantiation
3884 && !PRIMARY_TEMPLATE_P (template)
3885 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL
)
3887 found
= xref_tag_from_type (TREE_TYPE (template),
3888 DECL_NAME (template),
3893 /* Create the type. */
3894 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
3896 if (!is_partial_instantiation
)
3897 t
= start_enum (TYPE_IDENTIFIER (template_type
));
3899 /* We don't want to call start_enum for this type, since
3900 the values for the enumeration constants may involve
3901 template parameters. And, no one should be interested
3902 in the enumeration constants for such a type. */
3903 t
= make_node (ENUMERAL_TYPE
);
3907 t
= make_lang_type (TREE_CODE (template_type
));
3908 CLASSTYPE_DECLARED_CLASS (t
)
3909 = CLASSTYPE_DECLARED_CLASS (template_type
);
3910 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
3911 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
3912 TYPE_FOR_JAVA (t
) = TYPE_FOR_JAVA (template_type
);
3914 /* A local class. Make sure the decl gets registered properly. */
3915 if (context
== current_function_decl
)
3916 pushtag (DECL_NAME (template), t
, 0);
3919 /* If we called start_enum or pushtag above, this information
3920 will already be set up. */
3923 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3925 type_decl
= create_implicit_typedef (DECL_NAME (template), t
);
3926 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
3927 TYPE_STUB_DECL (t
) = type_decl
;
3928 DECL_SOURCE_FILE (type_decl
)
3929 = DECL_SOURCE_FILE (TYPE_STUB_DECL (template_type
));
3930 DECL_SOURCE_LINE (type_decl
)
3931 = DECL_SOURCE_LINE (TYPE_STUB_DECL (template_type
));
3934 type_decl
= TYPE_NAME (t
);
3936 /* Set up the template information. We have to figure out which
3937 template is the immediate parent if this is a full
3939 if (parm_depth
== 1 || is_partial_instantiation
3940 || !PRIMARY_TEMPLATE_P (template))
3941 /* This case is easy; there are no member templates involved. */
3945 /* This is a full instantiation of a member template. There
3946 should be some partial instantiation of which this is an
3949 for (found
= DECL_TEMPLATE_INSTANTIATIONS (template);
3950 found
; found
= TREE_CHAIN (found
))
3953 tree tmpl
= CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found
));
3955 /* We only want partial instantiations, here, not
3956 specializations or full instantiations. */
3957 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found
))
3958 || !uses_template_parms (TREE_VALUE (found
)))
3961 /* Temporarily reduce by one the number of levels in the
3962 ARGLIST and in FOUND so as to avoid comparing the
3963 last set of arguments. */
3964 TREE_VEC_LENGTH (arglist
)--;
3965 TREE_VEC_LENGTH (TREE_PURPOSE (found
)) --;
3967 /* See if the arguments match. If they do, then TMPL is
3968 the partial instantiation we want. */
3969 success
= comp_template_args (TREE_PURPOSE (found
), arglist
);
3971 /* Restore the argument vectors to their full size. */
3972 TREE_VEC_LENGTH (arglist
)++;
3973 TREE_VEC_LENGTH (TREE_PURPOSE (found
))++;
3983 my_friendly_abort (0);
3986 SET_TYPE_TEMPLATE_INFO (t
,
3987 tree_cons (found
, arglist
, NULL_TREE
));
3988 DECL_TEMPLATE_INSTANTIATIONS (template)
3989 = tree_cons (arglist
, t
,
3990 DECL_TEMPLATE_INSTANTIATIONS (template));
3992 if (TREE_CODE (t
) == ENUMERAL_TYPE
3993 && !is_partial_instantiation
)
3994 /* Now that the type has been registered on the instantiations
3995 list, we set up the enumerators. Because the enumeration
3996 constants may involve the enumeration type itself, we make
3997 sure to register the type first, and then create the
3998 constants. That way, doing tsubst_expr for the enumeration
3999 constants won't result in recursive calls here; we'll find
4000 the instantiation and exit above. */
4001 tsubst_enum (template_type
, t
, arglist
);
4003 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4005 if (TREE_CODE (t
) != ENUMERAL_TYPE
)
4006 DECL_NAME (type_decl
) = classtype_mangled_name (t
);
4007 DECL_ASSEMBLER_NAME (type_decl
) = DECL_NAME (type_decl
);
4008 if (!is_partial_instantiation
)
4010 DECL_ASSEMBLER_NAME (type_decl
)
4011 = get_identifier (build_overload_name (t
, 1, 1));
4013 /* For backwards compatibility; code that uses
4014 -fexternal-templates expects looking up a template to
4015 instantiate it. I think DDD still relies on this.
4016 (jason 8/20/1998) */
4017 if (TREE_CODE (t
) != ENUMERAL_TYPE
4018 && flag_external_templates
4019 && CLASSTYPE_INTERFACE_KNOWN (TREE_TYPE (template))
4020 && ! CLASSTYPE_INTERFACE_ONLY (TREE_TYPE (template)))
4021 add_pending_template (t
);
4024 /* If the type makes use of template parameters, the
4025 code that generates debugging information will crash. */
4026 DECL_IGNORED_P (TYPE_STUB_DECL (t
)) = 1;
4038 /* Called from for_each_template_parm via walk_tree. */
4041 for_each_template_parm_r (tp
, walk_subtrees
, d
)
4047 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
4048 tree_fn_t fn
= pfd
->fn
;
4049 void *data
= pfd
->data
;
4051 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't'
4052 && for_each_template_parm (TYPE_CONTEXT (t
), fn
, data
))
4053 return error_mark_node
;
4055 switch (TREE_CODE (t
))
4058 if (TYPE_PTRMEMFUNC_FLAG (t
))
4064 if (!TYPE_TEMPLATE_INFO (t
))
4066 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t
)),
4068 return error_mark_node
;
4072 /* Since we're not going to walk subtrees, we have to do this
4074 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t
), fn
, data
))
4075 return error_mark_node
;
4078 /* Check the return type. */
4079 if (for_each_template_parm (TREE_TYPE (t
), fn
, data
))
4080 return error_mark_node
;
4082 /* Check the parameter types. Since default arguments are not
4083 instantiated until they are needed, the TYPE_ARG_TYPES may
4084 contain expressions that involve template parameters. But,
4085 no-one should be looking at them yet. And, once they're
4086 instantiated, they don't contain template parameters, so
4087 there's no point in looking at them then, either. */
4091 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
4092 if (for_each_template_parm (TREE_VALUE (parm
), fn
, data
))
4093 return error_mark_node
;
4095 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4096 want walk_tree walking into them itself. */
4103 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
)
4104 && for_each_template_parm (DECL_TI_ARGS (t
), fn
, data
))
4105 return error_mark_node
;
4110 if (DECL_CONTEXT (t
)
4111 && for_each_template_parm (DECL_CONTEXT (t
), fn
, data
))
4112 return error_mark_node
;
4115 case TEMPLATE_TEMPLATE_PARM
:
4116 /* Record template parameters such as `T' inside `TT<T>'. */
4117 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
)
4118 && for_each_template_parm (TYPE_TI_ARGS (t
), fn
, data
))
4119 return error_mark_node
;
4122 case TEMPLATE_TYPE_PARM
:
4123 case TEMPLATE_PARM_INDEX
:
4124 if (fn
&& (*fn
)(t
, data
))
4125 return error_mark_node
;
4127 return error_mark_node
;
4131 /* A template template parameter is encountered */
4132 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
)
4133 && for_each_template_parm (TREE_TYPE (t
), fn
, data
))
4134 return error_mark_node
;
4136 /* Already substituted template template parameter */
4141 if (!fn
|| for_each_template_parm (TYPENAME_TYPE_FULLNAME (t
), fn
, data
))
4142 return error_mark_node
;
4146 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
4147 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4148 (TREE_TYPE (t
)), fn
, data
))
4149 return error_mark_node
;
4154 /* If there's no type, then this thing must be some expression
4155 involving template parameters. */
4156 if (!fn
&& !TREE_TYPE (t
))
4157 return error_mark_node
;
4162 case REINTERPRET_CAST_EXPR
:
4163 case CONST_CAST_EXPR
:
4164 case STATIC_CAST_EXPR
:
4165 case DYNAMIC_CAST_EXPR
:
4170 case PSEUDO_DTOR_EXPR
:
4172 return error_mark_node
;
4179 /* We didn't find any template parameters we liked. */
4183 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM, or
4184 TEMPLATE_PARM_INDEX in T, call FN with the parameter and the DATA.
4185 If FN returns non-zero, the iteration is terminated, and
4186 for_each_template_parm returns 1. Otherwise, the iteration
4187 continues. If FN never returns a non-zero value, the value
4188 returned by for_each_template_parm is 0. If FN is NULL, it is
4189 considered to be the function which always returns 1. */
4192 for_each_template_parm (t
, fn
, data
)
4197 struct pair_fn_data pfd
;
4203 /* Walk the tree. */
4204 return walk_tree (&t
, for_each_template_parm_r
, &pfd
) != NULL_TREE
;
4208 uses_template_parms (t
)
4211 return for_each_template_parm (t
, 0, 0);
4214 static struct tinst_level
*current_tinst_level
;
4215 static struct tinst_level
*free_tinst_level
;
4216 static int tinst_depth
;
4217 extern int max_tinst_depth
;
4218 #ifdef GATHER_STATISTICS
4221 static int tinst_level_tick
;
4222 static int last_template_error_tick
;
4224 /* Print out all the template instantiations that we are currently
4225 working on. If ERR, we are being called from cp_thing, so do
4226 the right thing for an error message. */
4229 print_template_context (err
)
4232 struct tinst_level
*p
= current_tinst_level
;
4234 char *file
= input_filename
;
4238 if (current_function_decl
!= p
->decl
4239 && current_function_decl
!= NULL_TREE
)
4240 /* We can get here during the processing of some synthesized
4241 method. Then, p->decl will be the function that's causing
4246 if (current_function_decl
== p
->decl
)
4247 /* Avoid redundancy with the the "In function" line. */;
4249 fprintf (stderr
, "%s: In instantiation of `%s':\n",
4250 file
, decl_as_string (p
->decl
, TS_DECL_TYPE
| TS_FUNC_NORETURN
));
4258 for (; p
; p
= p
->next
)
4260 fprintf (stderr
, "%s:%d: instantiated from `%s'\n", file
, line
,
4261 decl_as_string (p
->decl
, TS_DECL_TYPE
| TS_FUNC_NORETURN
));
4265 fprintf (stderr
, "%s:%d: instantiated from here\n", file
, line
);
4268 /* Called from cp_thing to print the template context for an error. */
4271 maybe_print_template_context ()
4273 if (last_template_error_tick
== tinst_level_tick
4274 || current_tinst_level
== 0)
4277 last_template_error_tick
= tinst_level_tick
;
4278 print_template_context (1);
4282 push_tinst_level (d
)
4285 struct tinst_level
*new;
4287 if (tinst_depth
>= max_tinst_depth
)
4289 /* If the instantiation in question still has unbound template parms,
4290 we don't really care if we can't instantiate it, so just return.
4291 This happens with base instantiation for implicit `typename'. */
4292 if (uses_template_parms (d
))
4295 last_template_error_tick
= tinst_level_tick
;
4296 error ("template instantiation depth exceeds maximum of %d",
4298 error (" (use -ftemplate-depth-NN to increase the maximum)");
4299 cp_error (" instantiating `%D'", d
);
4301 print_template_context (0);
4306 if (free_tinst_level
)
4308 new = free_tinst_level
;
4309 free_tinst_level
= new->next
;
4312 new = (struct tinst_level
*) xmalloc (sizeof (struct tinst_level
));
4316 new->file
= input_filename
;
4317 new->next
= current_tinst_level
;
4318 current_tinst_level
= new;
4321 #ifdef GATHER_STATISTICS
4322 if (tinst_depth
> depth_reached
)
4323 depth_reached
= tinst_depth
;
4333 struct tinst_level
*old
= current_tinst_level
;
4335 /* Restore the filename and line number stashed away when we started
4336 this instantiation. */
4338 input_filename
= old
->file
;
4339 extract_interface_info ();
4341 current_tinst_level
= old
->next
;
4342 old
->next
= free_tinst_level
;
4343 free_tinst_level
= old
;
4348 struct tinst_level
*
4351 struct tinst_level
*p
= current_tinst_level
;
4354 for (; p
->next
; p
= p
->next
)
4359 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4360 vector of template arguments, as for tsubst.
4362 Returns an appropriate tsbust'd friend declaration. */
4365 tsubst_friend_function (decl
, args
)
4371 char *file
= input_filename
;
4373 lineno
= DECL_SOURCE_LINE (decl
);
4374 input_filename
= DECL_SOURCE_FILE (decl
);
4376 if (TREE_CODE (decl
) == FUNCTION_DECL
4377 && DECL_TEMPLATE_INSTANTIATION (decl
)
4378 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
4379 /* This was a friend declared with an explicit template
4380 argument list, e.g.:
4384 to indicate that f was a template instantiation, not a new
4385 function declaration. Now, we have to figure out what
4386 instantiation of what template. */
4393 = lookup_template_function (tsubst_expr (DECL_TI_TEMPLATE (decl
),
4394 args
, /*complain=*/1,
4396 tsubst (DECL_TI_ARGS (decl
),
4397 args
, /*complain=*/1,
4399 new_friend
= tsubst (decl
, args
, /*complain=*/1, NULL_TREE
);
4400 tmpl
= determine_specialization (template_id
, new_friend
,
4402 /*need_member_template=*/0);
4403 new_friend
= instantiate_template (tmpl
, new_args
);
4407 new_friend
= tsubst (decl
, args
, /*complain=*/1, NULL_TREE
);
4409 /* The NEW_FRIEND will look like an instantiation, to the
4410 compiler, but is not an instantiation from the point of view of
4411 the language. For example, we might have had:
4413 template <class T> struct S {
4414 template <class U> friend void f(T, U);
4417 Then, in S<int>, template <class U> void f(int, U) is not an
4418 instantiation of anything. */
4419 DECL_USE_TEMPLATE (new_friend
) = 0;
4420 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4421 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
4423 /* The mangled name for the NEW_FRIEND is incorrect. The call to
4424 tsubst will have resulted in a call to
4425 set_mangled_name_for_template_decl. But, the function is not a
4426 template instantiation and should not be mangled like one.
4427 Therefore, we remangle the function name. We don't have to do
4428 this if the NEW_FRIEND is a template since
4429 set_mangled_name_for_template_decl doesn't do anything if the
4430 function declaration still uses template arguments. */
4431 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
4433 set_mangled_name_for_decl (new_friend
);
4434 DECL_RTL (new_friend
) = 0;
4435 make_decl_rtl (new_friend
, NULL_PTR
, 1);
4438 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
4441 tree new_friend_template_info
;
4442 tree new_friend_result_template_info
;
4444 int new_friend_is_defn
;
4446 /* We must save some information from NEW_FRIEND before calling
4447 duplicate decls since that function will free NEW_FRIEND if
4449 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
4450 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
4452 /* This declaration is a `primary' template. */
4453 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
4456 = DECL_INITIAL (DECL_RESULT (new_friend
)) != NULL_TREE
;
4457 new_friend_result_template_info
4458 = DECL_TEMPLATE_INFO (DECL_RESULT (new_friend
));
4462 new_friend_is_defn
= DECL_INITIAL (new_friend
) != NULL_TREE
;
4463 new_friend_result_template_info
= NULL_TREE
;
4466 /* Inside pushdecl_namespace_level, we will push into the
4467 current namespace. However, the friend function should
4468 tyically go into the namespace of the template. */
4469 ns
= decl_namespace_context (new_friend
);
4470 push_nested_namespace (ns
);
4471 old_decl
= pushdecl_namespace_level (new_friend
);
4472 pop_nested_namespace (ns
);
4474 if (old_decl
!= new_friend
)
4476 /* This new friend declaration matched an existing
4477 declaration. For example, given:
4479 template <class T> void f(T);
4480 template <class U> class C {
4481 template <class T> friend void f(T) {}
4484 the friend declaration actually provides the definition
4485 of `f', once C has been instantiated for some type. So,
4486 old_decl will be the out-of-class template declaration,
4487 while new_friend is the in-class definition.
4489 But, if `f' was called before this point, the
4490 instantiation of `f' will have DECL_TI_ARGS corresponding
4491 to `T' but not to `U', references to which might appear
4492 in the definition of `f'. Previously, the most general
4493 template for an instantiation of `f' was the out-of-class
4494 version; now it is the in-class version. Therefore, we
4495 run through all specialization of `f', adding to their
4496 DECL_TI_ARGS appropriately. In particular, they need a
4497 new set of outer arguments, corresponding to the
4498 arguments for this class instantiation.
4500 The same situation can arise with something like this:
4503 template <class T> class C {
4507 when `C<int>' is instantiated. Now, `f(int)' is defined
4510 if (!new_friend_is_defn
)
4511 /* On the other hand, if the in-class declaration does
4512 *not* provide a definition, then we don't want to alter
4513 existing definitions. We can just leave everything
4518 /* Overwrite whatever template info was there before, if
4519 any, with the new template information pertaining to
4521 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
4523 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
4524 /* duplicate_decls will take care of this case. */
4529 tree new_friend_args
;
4531 DECL_TEMPLATE_INFO (DECL_RESULT (old_decl
))
4532 = new_friend_result_template_info
;
4534 new_friend_args
= TI_ARGS (new_friend_template_info
);
4535 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (old_decl
);
4539 tree spec
= TREE_VALUE (t
);
4542 = add_outermost_template_args (new_friend_args
,
4543 DECL_TI_ARGS (spec
));
4546 /* Now, since specializations are always supposed to
4547 hang off of the most general template, we must move
4549 t
= most_general_template (old_decl
);
4552 DECL_TEMPLATE_SPECIALIZATIONS (t
)
4553 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t
),
4554 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
));
4555 DECL_TEMPLATE_SPECIALIZATIONS (old_decl
) = NULL_TREE
;
4560 /* The information from NEW_FRIEND has been merged into OLD_DECL
4561 by duplicate_decls. */
4562 new_friend
= old_decl
;
4565 else if (TYPE_SIZE (DECL_CONTEXT (new_friend
)))
4567 /* Check to see that the declaration is really present, and,
4568 possibly obtain an improved declaration. */
4569 tree fn
= check_classfn (DECL_CONTEXT (new_friend
),
4578 input_filename
= file
;
4582 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
4583 template arguments, as for tsubst.
4585 Returns an appropriate tsbust'd friend type. */
4588 tsubst_friend_class (friend_tmpl
, args
)
4595 /* First, we look for a class template. */
4596 tmpl
= lookup_name (DECL_NAME (friend_tmpl
), /*prefer_type=*/0);
4598 /* But, if we don't find one, it might be because we're in a
4599 situation like this:
4607 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
4608 for `S<int>', not the TEMPLATE_DECL. */
4609 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
4611 tmpl
= lookup_name (DECL_NAME (friend_tmpl
), /*prefer_type=*/1);
4612 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
4615 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
4617 /* The friend template has already been declared. Just
4618 check to see that the declarations match, and install any new
4619 default parameters. We must tsubst the default parameters,
4620 of course. We only need the innermost template parameters
4621 because that is all that redeclare_class_template will look
4624 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
4625 args
, /*complain=*/1);
4626 redeclare_class_template (TREE_TYPE (tmpl
), parms
);
4627 friend_type
= TREE_TYPE (tmpl
);
4631 /* The friend template has not already been declared. In this
4632 case, the instantiation of the template class will cause the
4633 injection of this template into the global scope. */
4634 tmpl
= tsubst (friend_tmpl
, args
, /*complain=*/1, NULL_TREE
);
4636 /* The new TMPL is not an instantiation of anything, so we
4637 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
4638 the new type because that is supposed to be the corresponding
4639 template decl, i.e., TMPL. */
4640 DECL_USE_TEMPLATE (tmpl
) = 0;
4641 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
4642 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
4644 /* Inject this template into the global scope. */
4645 friend_type
= TREE_TYPE (pushdecl_top_level (tmpl
));
4652 instantiate_class_template (type
)
4655 tree
template, args
, pattern
, t
;
4658 if (type
== error_mark_node
)
4659 return error_mark_node
;
4661 if (TYPE_BEING_DEFINED (type
) || TYPE_SIZE (type
))
4664 /* Figure out which template is being instantiated. */
4665 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
4666 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL
, 279);
4668 /* Figure out which arguments are being used to do the
4670 args
= CLASSTYPE_TI_ARGS (type
);
4671 PARTIAL_INSTANTIATION_P (type
) = uses_template_parms (args
);
4673 if (pedantic
&& PARTIAL_INSTANTIATION_P (type
))
4674 /* If this is a partial instantiation, then we can't instantiate
4675 the type; there's no telling whether or not one of the
4676 template parameters might eventually be instantiated to some
4677 value that results in a specialization being used. For
4689 Now, the `S<U>' in `f<int>' is the specialization, not an
4690 instantiation of the original template. */
4693 /* Determine what specialization of the original template to
4695 if (PARTIAL_INSTANTIATION_P (type
))
4696 /* There's no telling which specialization is appropriate at this
4697 point. Since all peeking at the innards of this partial
4698 instantiation are extensions (like the "implicit typename"
4699 extension, which allows users to omit the keyword `typename' on
4700 names that are declared as types in template base classes), we
4701 are free to do what we please.
4703 Trying to figure out which partial instantiation to use can
4704 cause a crash. (Some of the template arguments don't even have
4705 types.) So, we just use the most general version. */
4709 t
= most_specialized_class (template, args
);
4711 if (t
== error_mark_node
)
4713 const char *str
= "candidates are:";
4714 cp_error ("ambiguous class template instantiation for `%#T'", type
);
4715 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (template); t
;
4718 if (get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4721 cp_error_at ("%s %+#T", str
, TREE_TYPE (t
));
4725 TYPE_BEING_DEFINED (type
) = 1;
4726 return error_mark_node
;
4731 pattern
= TREE_TYPE (t
);
4733 pattern
= TREE_TYPE (template);
4735 /* If the template we're instantiating is incomplete, then clearly
4736 there's nothing we can do. */
4737 if (TYPE_SIZE (pattern
) == NULL_TREE
)
4740 /* If this is a partial instantiation, don't tsubst anything. We will
4741 only use this type for implicit typename, so the actual contents don't
4742 matter. All that matters is whether a particular name is a type. */
4743 if (PARTIAL_INSTANTIATION_P (type
))
4745 /* The fields set here must be kept in sync with those cleared
4746 in begin_class_definition. */
4747 TYPE_BINFO_BASETYPES (type
) = TYPE_BINFO_BASETYPES (pattern
);
4748 TYPE_FIELDS (type
) = TYPE_FIELDS (pattern
);
4749 TYPE_METHODS (type
) = TYPE_METHODS (pattern
);
4750 CLASSTYPE_TAGS (type
) = CLASSTYPE_TAGS (pattern
);
4751 /* Pretend that the type is complete, so that we will look
4752 inside it during name lookup and such. */
4753 TYPE_SIZE (type
) = integer_zero_node
;
4757 /* If we've recursively instantiated too many templates, stop. */
4758 if (! push_tinst_level (type
))
4761 /* Now we're really doing the instantiation. Mark the type as in
4762 the process of being defined. */
4763 TYPE_BEING_DEFINED (type
) = 1;
4765 maybe_push_to_top_level (uses_template_parms (type
));
4769 /* This TYPE is actually a instantiation of of a partial
4770 specialization. We replace the innermost set of ARGS with
4771 the arguments appropriate for substitution. For example,
4774 template <class T> struct S {};
4775 template <class T> struct S<T*> {};
4777 and supposing that we are instantiating S<int*>, ARGS will
4778 present be {int*} but we need {int}. */
4780 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
),
4783 /* If there were multiple levels in ARGS, replacing the
4784 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
4785 want, so we make a copy first. */
4786 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
4788 args
= copy_node (args
);
4789 SET_TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
), inner_args
);
4795 if (flag_external_templates
)
4797 if (flag_alt_external_templates
)
4799 CLASSTYPE_INTERFACE_ONLY (type
) = interface_only
;
4800 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (type
, interface_unknown
);
4801 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4802 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4803 && CLASSTYPE_INTERFACE_KNOWN (type
));
4807 CLASSTYPE_INTERFACE_ONLY (type
) = CLASSTYPE_INTERFACE_ONLY (pattern
);
4808 SET_CLASSTYPE_INTERFACE_UNKNOWN_X
4809 (type
, CLASSTYPE_INTERFACE_UNKNOWN (pattern
));
4810 CLASSTYPE_VTABLE_NEEDS_WRITING (type
)
4811 = (! CLASSTYPE_INTERFACE_ONLY (type
)
4812 && CLASSTYPE_INTERFACE_KNOWN (type
));
4817 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
4818 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 1;
4821 TYPE_HAS_CONSTRUCTOR (type
) = TYPE_HAS_CONSTRUCTOR (pattern
);
4822 TYPE_HAS_DESTRUCTOR (type
) = TYPE_HAS_DESTRUCTOR (pattern
);
4823 TYPE_OVERLOADS_CALL_EXPR (type
) = TYPE_OVERLOADS_CALL_EXPR (pattern
);
4824 TYPE_OVERLOADS_ARRAY_REF (type
) = TYPE_OVERLOADS_ARRAY_REF (pattern
);
4825 TYPE_OVERLOADS_ARROW (type
) = TYPE_OVERLOADS_ARROW (pattern
);
4826 TYPE_GETS_NEW (type
) = TYPE_GETS_NEW (pattern
);
4827 TYPE_GETS_DELETE (type
) = TYPE_GETS_DELETE (pattern
);
4828 TYPE_VEC_DELETE_TAKES_SIZE (type
) = TYPE_VEC_DELETE_TAKES_SIZE (pattern
);
4829 TYPE_HAS_ASSIGN_REF (type
) = TYPE_HAS_ASSIGN_REF (pattern
);
4830 TYPE_HAS_CONST_ASSIGN_REF (type
) = TYPE_HAS_CONST_ASSIGN_REF (pattern
);
4831 TYPE_HAS_ABSTRACT_ASSIGN_REF (type
) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern
);
4832 TYPE_HAS_INIT_REF (type
) = TYPE_HAS_INIT_REF (pattern
);
4833 TYPE_HAS_CONST_INIT_REF (type
) = TYPE_HAS_CONST_INIT_REF (pattern
);
4834 TYPE_HAS_DEFAULT_CONSTRUCTOR (type
) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern
);
4835 TYPE_HAS_CONVERSION (type
) = TYPE_HAS_CONVERSION (pattern
);
4836 TYPE_USES_COMPLEX_INHERITANCE (type
)
4837 = TYPE_USES_COMPLEX_INHERITANCE (pattern
);
4838 TYPE_USES_MULTIPLE_INHERITANCE (type
)
4839 = TYPE_USES_MULTIPLE_INHERITANCE (pattern
);
4840 TYPE_USES_VIRTUAL_BASECLASSES (type
)
4841 = TYPE_USES_VIRTUAL_BASECLASSES (pattern
);
4842 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
4843 TYPE_ALIGN (type
) = TYPE_ALIGN (pattern
);
4844 TYPE_FOR_JAVA (type
) = TYPE_FOR_JAVA (pattern
); /* For libjava's JArray<T> */
4845 if (ANON_AGGR_TYPE_P (pattern
))
4846 SET_ANON_AGGR_TYPE_P (type
);
4848 if (TYPE_BINFO_BASETYPES (pattern
))
4850 tree base_list
= NULL_TREE
;
4851 tree pbases
= TYPE_BINFO_BASETYPES (pattern
);
4854 /* Substitute into each of the bases to determine the actual
4856 for (i
= 0; i
< TREE_VEC_LENGTH (pbases
); ++i
)
4862 pbase
= TREE_VEC_ELT (pbases
, i
);
4864 /* Substitue to figure out the base class. */
4865 base
= tsubst (BINFO_TYPE (pbase
), args
,
4866 /*complain=*/1, NULL_TREE
);
4867 if (base
== error_mark_node
)
4870 /* Calculate the correct access node. */
4871 if (TREE_VIA_VIRTUAL (pbase
))
4873 if (TREE_VIA_PUBLIC (pbase
))
4874 access
= access_public_virtual_node
;
4875 else if (TREE_VIA_PROTECTED (pbase
))
4876 access
= access_protected_virtual_node
;
4878 access
= access_private_virtual_node
;
4882 if (TREE_VIA_PUBLIC (pbase
))
4883 access
= access_public_node
;
4884 else if (TREE_VIA_PROTECTED (pbase
))
4885 access
= access_protected_node
;
4887 access
= access_private_node
;
4890 base_list
= tree_cons (access
, base
, base_list
);
4893 /* The list is now in reverse order; correct that. */
4894 base_list
= nreverse (base_list
);
4896 /* Now call xref_basetypes to set up all the base-class
4898 xref_basetypes (TREE_CODE (pattern
) == RECORD_TYPE
4899 ? (CLASSTYPE_DECLARED_CLASS (pattern
)
4900 ? class_type_node
: record_type_node
)
4902 DECL_NAME (TYPE_NAME (pattern
)),
4907 /* Now that our base classes are set up, enter the scope of the
4908 class, so that name lookups into base classes, etc. will work
4909 corectly. This is precisely analagous to what we do in
4910 begin_class_definition when defining an ordinary non-template
4912 pushclass (type
, 1);
4914 for (t
= CLASSTYPE_TAGS (pattern
); t
; t
= TREE_CHAIN (t
))
4916 tree tag
= TREE_VALUE (t
);
4917 tree name
= TYPE_IDENTIFIER (tag
);
4920 newtag
= tsubst (tag
, args
, /*complain=*/1, NULL_TREE
);
4921 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
4923 if (TYPE_LANG_SPECIFIC (tag
) && CLASSTYPE_IS_TEMPLATE (tag
))
4924 /* Unfortunately, lookup_template_class sets
4925 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
4926 instantiation (i.e., for the type of a member template
4927 class nested within a template class.) This behavior is
4928 required for maybe_process_partial_specialization to work
4929 correctly, but is not accurate in this case; the TAG is not
4930 an instantiation of anything. (The corresponding
4931 TEMPLATE_DECL is an instantiation, but the TYPE is not.) */
4932 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
4934 /* Now, we call pushtag to put this NEWTAG into the scope of
4935 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
4936 pushtag calling push_template_decl. We don't have to do
4937 this for enums because it will already have been done in
4940 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
4941 pushtag (name
, newtag
, /*globalize=*/0);
4945 /* Don't replace enum constants here. */
4946 for (t
= TYPE_FIELDS (pattern
); t
; t
= TREE_CHAIN (t
))
4947 if (TREE_CODE (t
) != CONST_DECL
)
4951 /* The the file and line for this declaration, to assist in
4952 error message reporting. Since we called push_tinst_level
4953 above, we don't need to restore these. */
4954 lineno
= DECL_SOURCE_LINE (t
);
4955 input_filename
= DECL_SOURCE_FILE (t
);
4957 r
= tsubst (t
, args
, /*complain=*/1, NULL_TREE
);
4958 if (TREE_CODE (r
) == VAR_DECL
)
4962 if (DECL_DEFINED_IN_CLASS_P (r
))
4963 init
= tsubst_expr (DECL_INITIAL (t
), args
,
4964 /*complain=*/1, NULL_TREE
);
4968 finish_static_data_member_decl (r
, init
,
4969 /*asmspec_tree=*/NULL_TREE
,
4972 if (DECL_DEFINED_IN_CLASS_P (r
))
4973 check_static_variable_definition (r
, TREE_TYPE (r
));
4976 /* R will have a TREE_CHAIN if and only if it has already been
4977 processed by finish_member_declaration. This can happen
4978 if, for example, it is a TYPE_DECL for a class-scoped
4979 ENUMERAL_TYPE; such a thing will already have been added to
4980 the field list by tsubst_enum above. */
4981 if (!TREE_CHAIN (r
))
4983 set_current_access_from_decl (r
);
4984 finish_member_declaration (r
);
4988 /* Set up the list (TYPE_METHODS) and vector (CLASSTYPE_METHOD_VEC)
4989 for this instantiation. */
4990 for (t
= TYPE_METHODS (pattern
); t
; t
= TREE_CHAIN (t
))
4992 tree r
= tsubst (t
, args
, /*complain=*/1, NULL_TREE
);
4993 set_current_access_from_decl (r
);
4994 finish_member_declaration (r
);
4997 /* Construct the DECL_FRIENDLIST for the new class type. */
4998 typedecl
= TYPE_MAIN_DECL (type
);
4999 for (t
= DECL_FRIENDLIST (TYPE_MAIN_DECL (pattern
));
5005 for (friends
= TREE_VALUE (t
);
5006 friends
!= NULL_TREE
;
5007 friends
= TREE_CHAIN (friends
))
5008 if (TREE_PURPOSE (friends
) == error_mark_node
)
5010 tsubst_friend_function (TREE_VALUE (friends
),
5014 tsubst_copy (TREE_PURPOSE (t
), args
,
5015 /*complain=*/1, NULL_TREE
),
5016 tsubst (TREE_PURPOSE (friends
), args
,
5017 /*complain=*/1, NULL_TREE
));
5020 for (t
= CLASSTYPE_FRIEND_CLASSES (pattern
);
5024 tree friend_type
= TREE_VALUE (t
);
5025 tree new_friend_type
;
5027 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
5028 new_friend_type
= tsubst_friend_class (friend_type
, args
);
5029 else if (uses_template_parms (friend_type
))
5030 new_friend_type
= tsubst (friend_type
, args
, /*complain=*/1,
5034 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
5036 /* The call to xref_tag_from_type does injection for friend
5038 push_nested_namespace (ns
);
5040 xref_tag_from_type (friend_type
, NULL_TREE
, 1);
5041 pop_nested_namespace (ns
);
5044 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
5045 /* Trick make_friend_class into realizing that the friend
5046 we're adding is a template, not an ordinary class. It's
5047 important that we use make_friend_class since it will
5048 perform some error-checking and output cross-reference
5050 ++processing_template_decl
;
5052 make_friend_class (type
, new_friend_type
);
5054 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
5055 --processing_template_decl
;
5058 for (t
= TYPE_FIELDS (type
); t
; t
= TREE_CHAIN (t
))
5059 if (TREE_CODE (t
) == FIELD_DECL
)
5061 TREE_TYPE (t
) = complete_type (TREE_TYPE (t
));
5062 require_complete_type (t
);
5065 /* Set the file and line number information to whatever is given for
5066 the class itself. This puts error messages involving generated
5067 implicit functions at a predictable point, and the same point
5068 that would be used for non-template classes. */
5069 lineno
= DECL_SOURCE_LINE (typedecl
);
5070 input_filename
= DECL_SOURCE_FILE (typedecl
);
5072 unreverse_member_declarations (type
);
5073 finish_struct_1 (type
);
5074 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
5076 /* Clear this now so repo_template_used is happy. */
5077 TYPE_BEING_DEFINED (type
) = 0;
5078 repo_template_used (type
);
5080 /* Now that the class is complete, instantiate default arguments for
5081 any member functions. We don't do this earlier because the
5082 default arguments may reference members of the class. */
5083 if (!PRIMARY_TEMPLATE_P (template))
5084 for (t
= TYPE_METHODS (type
); t
; t
= TREE_CHAIN (t
))
5085 if (TREE_CODE (t
) == FUNCTION_DECL
5086 /* Implicitly generated member functions will not have tmplate
5087 information; they are not instantiations, but instead are
5088 created "fresh" for each instantiation. */
5089 && DECL_TEMPLATE_INFO (t
))
5090 tsubst_default_arguments (t
);
5093 pop_from_top_level ();
5103 if (t1
== NULL_TREE
)
5104 return t2
== NULL_TREE
;
5105 if (t2
== NULL_TREE
)
5107 /* Don't care if one declares its arg const and the other doesn't -- the
5108 main variant of the arg type is all that matters. */
5109 if (TYPE_MAIN_VARIANT (TREE_VALUE (t1
))
5110 != TYPE_MAIN_VARIANT (TREE_VALUE (t2
)))
5112 return list_eq (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
5115 /* If arg is a non-type template parameter that does not depend on template
5116 arguments, fold it like we weren't in the body of a template. */
5119 maybe_fold_nontype_arg (arg
)
5122 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't'
5123 && !uses_template_parms (arg
))
5125 /* Sometimes, one of the args was an expression involving a
5126 template constant parameter, like N - 1. Now that we've
5127 tsubst'd, we might have something like 2 - 1. This will
5128 confuse lookup_template_class, so we do constant folding
5129 here. We have to unset processing_template_decl, to
5130 fool build_expr_from_tree() into building an actual
5133 int saved_processing_template_decl
= processing_template_decl
;
5134 processing_template_decl
= 0;
5135 arg
= fold (build_expr_from_tree (arg
));
5136 processing_template_decl
= saved_processing_template_decl
;
5141 /* Return the TREE_VEC with the arguments for the innermost template header,
5142 where ARGS is either that or the VEC of VECs for all the
5146 innermost_args (args
)
5149 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
5152 /* Substitute ARGS into the vector of template arguments T. */
5155 tsubst_template_arg_vector (t
, args
, complain
)
5160 int len
= TREE_VEC_LENGTH (t
), need_new
= 0, i
;
5161 tree
*elts
= (tree
*) alloca (len
* sizeof (tree
));
5163 bzero ((char *) elts
, len
* sizeof (tree
));
5165 for (i
= 0; i
< len
; i
++)
5167 if (TREE_VEC_ELT (t
, i
) != NULL_TREE
5168 && TREE_CODE (TREE_VEC_ELT (t
, i
)) == TREE_VEC
)
5169 elts
[i
] = tsubst_template_arg_vector (TREE_VEC_ELT (t
, i
),
5172 elts
[i
] = maybe_fold_nontype_arg
5173 (tsubst_expr (TREE_VEC_ELT (t
, i
), args
, complain
,
5176 if (elts
[i
] != TREE_VEC_ELT (t
, i
))
5183 t
= make_tree_vec (len
);
5184 for (i
= 0; i
< len
; i
++)
5185 TREE_VEC_ELT (t
, i
) = elts
[i
];
5190 /* Return the result of substituting ARGS into the template parameters
5191 given by PARMS. If there are m levels of ARGS and m + n levels of
5192 PARMS, then the result will contain n levels of PARMS. For
5193 example, if PARMS is `template <class T> template <class U>
5194 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5195 result will be `template <int*, double, class V>'. */
5198 tsubst_template_parms (parms
, args
, complain
)
5206 for (new_parms
= &r
;
5207 TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
5208 new_parms
= &(TREE_CHAIN (*new_parms
)),
5209 parms
= TREE_CHAIN (parms
))
5212 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms
)));
5215 for (i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
5217 tree default_value
=
5218 TREE_PURPOSE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
5220 TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms
), i
));
5222 TREE_VEC_ELT (new_vec
, i
)
5223 = build_tree_list (tsubst (default_value
, args
, complain
,
5225 tsubst (parm_decl
, args
, complain
,
5230 tree_cons (build_int_2 (0, (TMPL_PARMS_DEPTH (parms
)
5231 - TMPL_ARGS_DEPTH (args
))),
5232 new_vec
, NULL_TREE
);
5238 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5239 type T. If T is not an aggregate or enumeration type, it is
5240 handled as if by tsubst. IN_DECL is as for tsubst. If
5241 ENTERING_SCOPE is non-zero, T is the context for a template which
5242 we are presently tsubst'ing. Return the subsituted value. */
5245 tsubst_aggr_type (t
, args
, complain
, in_decl
, entering_scope
)
5255 switch (TREE_CODE (t
))
5258 if (TYPE_PTRMEMFUNC_P (t
))
5260 tree r
= build_ptrmemfunc_type
5261 (tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
));
5262 return cp_build_qualified_type_real (r
, TYPE_QUALS (t
),
5266 /* else fall through */
5269 if (TYPE_TEMPLATE_INFO (t
))
5275 /* First, determine the context for the type we are looking
5277 if (TYPE_CONTEXT (t
) != NULL_TREE
)
5278 context
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
,
5280 in_decl
, /*entering_scope=*/1);
5282 context
= NULL_TREE
;
5284 /* Then, figure out what arguments are appropriate for the
5285 type we are trying to find. For example, given:
5287 template <class T> struct S;
5288 template <class T, class U> void f(T, U) { S<U> su; }
5290 and supposing that we are instantiating f<int, double>,
5291 then our ARGS will be {int, double}, but, when looking up
5292 S we only want {double}. */
5293 argvec
= tsubst_template_arg_vector (TYPE_TI_ARGS (t
), args
,
5296 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
5299 return cp_build_qualified_type_real (r
, TYPE_QUALS (t
),
5303 /* This is not a template type, so there's nothing to do. */
5307 return tsubst (t
, args
, complain
, in_decl
);
5311 /* Substitute into the default argument ARG (a default argument for
5312 FN), which has the indicated TYPE. */
5315 tsubst_default_argument (fn
, type
, arg
)
5320 /* This default argument came from a template. Instantiate the
5321 default argument here, not in tsubst. In the case of
5330 we must be careful to do name lookup in the scope of S<T>,
5331 rather than in the current class. */
5332 if (DECL_CLASS_SCOPE_P (fn
))
5333 pushclass (DECL_REAL_CONTEXT (fn
), 2);
5335 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
), /*complain=*/1, NULL_TREE
);
5337 if (DECL_CLASS_SCOPE_P (fn
))
5340 /* Make sure the default argument is reasonable. */
5341 arg
= check_default_argument (type
, arg
);
5346 /* Substitute into all the default arguments for FN. */
5349 tsubst_default_arguments (fn
)
5355 tmpl_args
= DECL_TI_ARGS (fn
);
5357 /* If this function is not yet instantiated, we certainly don't need
5358 its default arguments. */
5359 if (uses_template_parms (tmpl_args
))
5362 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
5364 arg
= TREE_CHAIN (arg
))
5365 if (TREE_PURPOSE (arg
))
5366 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
,
5368 TREE_PURPOSE (arg
));
5371 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5372 (already computed) substitution of ARGS into TREE_TYPE (T), if
5373 appropriate. Return the result of the substitution. IN_DECL is as
5377 tsubst_decl (t
, args
, type
, in_decl
)
5384 char* saved_filename
;
5387 /* Set the filename and linenumber to improve error-reporting. */
5388 saved_lineno
= lineno
;
5389 saved_filename
= input_filename
;
5390 lineno
= DECL_SOURCE_LINE (t
);
5391 input_filename
= DECL_SOURCE_FILE (t
);
5393 switch (TREE_CODE (t
))
5397 /* We can get here when processing a member template function
5398 of a template class. */
5399 tree decl
= DECL_TEMPLATE_RESULT (t
);
5401 int is_template_template_parm
= DECL_TEMPLATE_TEMPLATE_PARM_P (t
);
5403 if (!is_template_template_parm
)
5405 /* We might already have an instance of this template.
5406 The ARGS are for the surrounding class type, so the
5407 full args contain the tsubst'd args for the context,
5408 plus the innermost args from the template decl. */
5409 tree tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
5410 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
5411 : DECL_TI_ARGS (DECL_RESULT (t
));
5414 full_args
= tsubst_template_arg_vector (tmpl_args
, args
,
5417 /* tsubst_template_arg_vector doesn't copy the vector if
5418 nothing changed. But, *something* should have
5420 my_friendly_assert (full_args
!= tmpl_args
, 0);
5422 spec
= retrieve_specialization (t
, full_args
);
5423 if (spec
!= NULL_TREE
)
5430 /* Make a new template decl. It will be similar to the
5431 original, but will record the current template arguments.
5432 We also create a new function declaration, which is just
5433 like the old one, but points to this new template, rather
5434 than the old one. */
5437 my_friendly_assert (DECL_LANG_SPECIFIC (r
) != 0, 0);
5438 TREE_CHAIN (r
) = NULL_TREE
;
5440 if (is_template_template_parm
)
5442 tree new_decl
= tsubst (decl
, args
, /*complain=*/1, in_decl
);
5443 DECL_RESULT (r
) = new_decl
;
5444 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5449 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, /*complain=*/1,
5450 in_decl
, /*entering_scope=*/1);
5451 DECL_CLASS_CONTEXT (r
)
5452 = tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
,
5453 /*complain=*/1, in_decl
,
5454 /*entering_scope=*/1);
5455 DECL_TEMPLATE_INFO (r
) = build_tree_list (t
, args
);
5457 if (TREE_CODE (decl
) == TYPE_DECL
)
5459 tree new_type
= tsubst (TREE_TYPE (t
), args
,
5460 /*complain=*/1, in_decl
);
5461 TREE_TYPE (r
) = new_type
;
5462 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
5463 DECL_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
5464 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
5468 tree new_decl
= tsubst (decl
, args
, /*complain=*/1, in_decl
);
5469 DECL_RESULT (r
) = new_decl
;
5470 DECL_TI_TEMPLATE (new_decl
) = r
;
5471 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
5472 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
5475 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5476 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
5477 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
5479 /* The template parameters for this new template are all the
5480 template parameters for the old template, except the
5481 outermost level of parameters. */
5482 DECL_TEMPLATE_PARMS (r
)
5483 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
5486 if (PRIMARY_TEMPLATE_P (t
))
5487 DECL_PRIMARY_TEMPLATE (r
) = r
;
5489 /* We don't partially instantiate partial specializations. */
5490 if (TREE_CODE (decl
) == TYPE_DECL
)
5493 for (spec
= DECL_TEMPLATE_SPECIALIZATIONS (t
);
5495 spec
= TREE_CHAIN (spec
))
5497 /* It helps to consider example here. Consider:
5508 Now, for example, we are instantiating S<int>::f(U u).
5509 We want to make a template:
5514 It will have a specialization, for the case U = int*, of
5518 void S<int>::f<int*>(int*);
5520 This specialization will be an instantiation of
5521 the specialization given in the declaration of S, with
5522 argument list int*. */
5524 tree fn
= TREE_VALUE (spec
);
5528 if (!DECL_TEMPLATE_SPECIALIZATION (fn
))
5529 /* Instantiations are on the same list, but they're of
5530 no concern to us. */
5533 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
5534 /* A full specialization. There's no need to record
5538 spec_args
= tsubst (DECL_TI_ARGS (fn
), args
,
5539 /*complain=*/1, in_decl
);
5540 new_fn
= tsubst (DECL_RESULT (most_general_template (fn
)),
5541 spec_args
, /*complain=*/1, in_decl
);
5542 DECL_TI_TEMPLATE (new_fn
) = fn
;
5543 register_specialization (new_fn
, r
,
5544 innermost_args (spec_args
));
5547 /* Record this partial instantiation. */
5548 register_specialization (r
, t
,
5549 DECL_TI_ARGS (DECL_RESULT (r
)));
5557 tree argvec
= NULL_TREE
;
5564 /* Nobody should be tsubst'ing into non-template functions. */
5565 my_friendly_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5567 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
5571 /* Calculate the most general template of which R is a
5572 specialization, and the complete set of arguments used to
5574 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
5576 = tsubst_template_arg_vector (DECL_TI_ARGS
5577 (DECL_TEMPLATE_RESULT (gen_tmpl
)),
5578 args
, /*complain=*/1);
5580 /* Check to see if we already have this specialization. */
5581 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5589 /* Here, we deal with the peculiar case:
5591 template <class T> struct S {
5592 template <class U> friend void f();
5594 template <class U> friend void f() {}
5596 template void f<double>();
5598 Here, the ARGS for the instantiation of will be {int,
5599 double}. But, we only need as many ARGS as there are
5600 levels of template parameters in CODE_PATTERN. We are
5601 careful not to get fooled into reducing the ARGS in
5604 template <class T> struct S { template <class U> void f(U); }
5605 template <class T> template <> void S<T>::f(int) {}
5607 which we can spot because the pattern will be a
5608 specialization in this case. */
5609 args_depth
= TMPL_ARGS_DEPTH (args
);
5611 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
5612 if (args_depth
> parms_depth
5613 && !DECL_TEMPLATE_SPECIALIZATION (t
))
5615 my_friendly_assert (DECL_FRIEND_P (t
), 0);
5617 if (parms_depth
> 1)
5621 args
= make_tree_vec (parms_depth
);
5622 for (i
= 0; i
< parms_depth
; ++i
)
5623 TREE_VEC_ELT (args
, i
) =
5624 TREE_VEC_ELT (args
, i
+ (args_depth
- parms_depth
));
5627 args
= TREE_VEC_ELT (args
, args_depth
- parms_depth
);
5632 /* This special case arises when we have something like this:
5634 template <class T> struct S {
5635 friend void f<int>(int, double);
5638 Here, the DECL_TI_TEMPLATE for the friend declaration
5639 will be a LOOKUP_EXPR or an IDENTIFIER_NODE. We are
5640 being called from tsubst_friend_function, and we want
5641 only to create a new decl (R) with appropriate types so
5642 that we can call determine_specialization. */
5643 my_friendly_assert ((TREE_CODE (DECL_TI_TEMPLATE (t
))
5645 || (TREE_CODE (DECL_TI_TEMPLATE (t
))
5646 == IDENTIFIER_NODE
), 0);
5647 gen_tmpl
= NULL_TREE
;
5650 if (DECL_CLASS_SCOPE_P (t
))
5652 if (DECL_NAME (t
) == constructor_name (DECL_CONTEXT (t
)))
5656 ctx
= tsubst_aggr_type (DECL_CLASS_CONTEXT (t
), args
,
5658 /*entering_scope=*/1);
5665 type
= tsubst (type
, args
, /*complain=*/1, in_decl
);
5666 if (type
== error_mark_node
)
5667 return error_mark_node
;
5669 /* We do NOT check for matching decls pushed separately at this
5670 point, as they may not represent instantiations of this
5671 template, and in any case are considered separate under the
5672 discrete model. Instead, see add_maybe_template. */
5676 DECL_USE_TEMPLATE (r
) = 0;
5677 TREE_TYPE (r
) = type
;
5680 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, /*complain=*/1, t
,
5681 /*entering_scope=*/1);
5682 DECL_CLASS_CONTEXT (r
) = ctx
;
5684 if (member
&& IDENTIFIER_TYPENAME_P (DECL_NAME (r
)))
5685 /* Type-conversion operator. Reconstruct the name, in
5686 case it's the name of one of the template's parameters. */
5687 DECL_NAME (r
) = build_typename_overload (TREE_TYPE (type
));
5689 DECL_ARGUMENTS (r
) = tsubst (DECL_ARGUMENTS (t
), args
,
5691 DECL_MAIN_VARIANT (r
) = r
;
5692 DECL_RESULT (r
) = NULL_TREE
;
5694 TREE_STATIC (r
) = 0;
5695 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
5696 DECL_EXTERNAL (r
) = 1;
5697 DECL_INTERFACE_KNOWN (r
) = 0;
5698 DECL_DEFER_OUTPUT (r
) = 0;
5699 TREE_CHAIN (r
) = NULL_TREE
;
5700 DECL_PENDING_INLINE_INFO (r
) = 0;
5701 DECL_PENDING_INLINE_P (r
) = 0;
5704 /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
5705 name. There's no need to do this in the special friend
5706 case mentioned above where GEN_TMPL is NULL. */
5709 DECL_TEMPLATE_INFO (r
)
5710 = tree_cons (gen_tmpl
, argvec
, NULL_TREE
);
5711 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5712 register_specialization (r
, gen_tmpl
, argvec
);
5714 /* Set the mangled name for R. */
5715 if (DECL_DESTRUCTOR_P (t
))
5716 DECL_ASSEMBLER_NAME (r
) = build_destructor_name (ctx
);
5719 /* Instantiations of template functions must be mangled
5720 specially, in order to conform to 14.5.5.1
5721 [temp.over.link]. */
5722 tree tmpl
= DECL_TI_TEMPLATE (t
);
5724 /* TMPL will be NULL if this is a specialization of a
5725 member function of a template class. */
5726 if (name_mangling_version
< 1
5727 || tmpl
== NULL_TREE
5728 || (member
&& !is_member_template (tmpl
)
5729 && !DECL_TEMPLATE_INFO (tmpl
)))
5730 set_mangled_name_for_decl (r
);
5732 set_mangled_name_for_template_decl (r
);
5736 make_decl_rtl (r
, NULL_PTR
, 1);
5738 /* Like grokfndecl. If we don't do this, pushdecl will
5739 mess up our TREE_CHAIN because it doesn't find a
5740 previous decl. Sigh. */
5742 && ! uses_template_parms (r
)
5743 && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
))
5745 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r
), r
);
5747 /* We're not supposed to instantiate default arguments
5748 until they are called, for a template. But, for a
5751 template <class T> void f ()
5752 { extern void g(int i = T()); }
5754 we should do the substitution when the template is
5755 instantiated. We handle the member function case in
5756 instantiate_class_template since the default arguments
5757 might refer to other members of the class. */
5759 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
5760 && !uses_template_parms (argvec
))
5761 tsubst_default_arguments (r
);
5764 /* Copy the list of befriending classes. */
5765 for (friends
= &DECL_BEFRIENDING_CLASSES (r
);
5767 friends
= &TREE_CHAIN (*friends
))
5769 *friends
= copy_node (*friends
);
5770 TREE_VALUE (*friends
) = tsubst (TREE_VALUE (*friends
),
5771 args
, /*complain=*/1,
5775 if (DECL_CONSTRUCTOR_P (r
))
5777 maybe_retrofit_in_chrg (r
);
5778 grok_ctor_properties (ctx
, r
);
5780 else if (DECL_OVERLOADED_OPERATOR_P (r
))
5781 grok_op_properties (r
, DECL_VIRTUAL_P (r
), DECL_FRIEND_P (r
));
5788 TREE_TYPE (r
) = type
;
5789 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type
), r
);
5791 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
5792 DECL_INITIAL (r
) = TREE_TYPE (r
);
5794 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
5795 /*complain=*/1, in_decl
);
5797 DECL_CONTEXT (r
) = NULL_TREE
;
5798 if (PROMOTE_PROTOTYPES
5799 && (TREE_CODE (type
) == INTEGER_TYPE
5800 || TREE_CODE (type
) == ENUMERAL_TYPE
)
5801 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
5802 DECL_ARG_TYPE (r
) = integer_type_node
;
5804 TREE_CHAIN (r
) = tsubst (TREE_CHAIN (t
), args
,
5805 /*complain=*/1, TREE_CHAIN (t
));
5813 TREE_TYPE (r
) = type
;
5814 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type
), r
);
5816 /* We don't have to set DECL_CONTEXT here; it is set by
5817 finish_member_declaration. */
5818 DECL_INITIAL (r
) = tsubst_expr (DECL_INITIAL (t
), args
,
5819 /*complain=*/1, in_decl
);
5820 TREE_CHAIN (r
) = NULL_TREE
;
5821 if (TREE_CODE (type
) == VOID_TYPE
)
5822 cp_error_at ("instantiation of `%D' as type void", r
);
5830 = tsubst_copy (DECL_INITIAL (t
), args
, /*complain=*/1, in_decl
);
5831 TREE_CHAIN (r
) = NULL_TREE
;
5836 if (DECL_IMPLICIT_TYPEDEF_P (t
))
5838 /* For an implicit typedef, we just want the implicit
5839 typedef for the tsubst'd type. We've already got the
5840 tsubst'd type, as TYPE, so we just need it's associated
5842 r
= TYPE_NAME (type
);
5845 else if (!DECL_LANG_SPECIFIC (t
))
5847 /* For a template type parameter, we don't have to do
5848 anything special. */
5849 r
= TYPE_NAME (type
);
5863 /* Nobody should be tsubst'ing into non-template variables. */
5864 my_friendly_assert (DECL_LANG_SPECIFIC (t
)
5865 && DECL_TEMPLATE_INFO (t
) != NULL_TREE
, 0);
5867 if (TYPE_P (CP_DECL_CONTEXT (t
)))
5868 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
,
5870 in_decl
, /*entering_scope=*/1);
5872 /* Subsequent calls to pushdecl will fill this in. */
5875 /* Check to see if we already have this specialization. */
5876 tmpl
= DECL_TI_TEMPLATE (t
);
5877 gen_tmpl
= most_general_template (tmpl
);
5878 argvec
= tsubst (DECL_TI_ARGS (t
), args
, /*complain=*/1, in_decl
);
5880 spec
= retrieve_specialization (gen_tmpl
, argvec
);
5882 spec
= retrieve_local_specialization (gen_tmpl
,
5883 current_function_decl
);
5891 /* This declaration is going to have to be around for a while,
5892 so me make sure it is on a saveable obstack. */
5895 TREE_TYPE (r
) = type
;
5896 c_apply_type_quals_to_decl (CP_TYPE_QUALS (type
), r
);
5897 DECL_CONTEXT (r
) = ctx
;
5899 /* Don't try to expand the initializer until someone tries to use
5900 this variable; otherwise we run into circular dependencies. */
5901 DECL_INITIAL (r
) = NULL_TREE
;
5905 DECL_CLASS_CONTEXT (r
) = DECL_CONTEXT (r
);
5907 /* For __PRETTY_FUNCTION__ we have to adjust the initializer. */
5908 if (DECL_PRETTY_FUNCTION_P (r
))
5910 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (t
),
5914 TREE_TYPE (r
) = TREE_TYPE (DECL_INITIAL (r
));
5917 /* If the template variable was marked TREE_ASM_WRITTEN, that
5918 means we don't need to write out any of the instantiations
5919 either. (__FUNCTION__ and its ilk are marked thusly.) */
5920 TREE_ASM_WRITTEN (r
) = TREE_ASM_WRITTEN (t
);
5922 /* Even if the original location is out of scope, the newly
5923 substituted one is not. */
5924 if (TREE_CODE (r
) == VAR_DECL
)
5925 DECL_DEAD_FOR_LOCAL (r
) = 0;
5927 /* A static data member declaration is always marked external
5928 when it is declared in-class, even if an initializer is
5929 present. We mimic the non-template processing here. */
5931 DECL_EXTERNAL (r
) = 1;
5933 DECL_TEMPLATE_INFO (r
) = tree_cons (tmpl
, argvec
, NULL_TREE
);
5934 SET_DECL_IMPLICIT_INSTANTIATION (r
);
5936 register_specialization (r
, gen_tmpl
, argvec
);
5938 register_local_specialization (r
, gen_tmpl
,
5939 current_function_decl
);
5941 TREE_CHAIN (r
) = NULL_TREE
;
5942 if (TREE_CODE (r
) == VAR_DECL
&& TREE_CODE (type
) == VOID_TYPE
)
5943 cp_error_at ("instantiation of `%D' as type void", r
);
5948 my_friendly_abort (0);
5951 /* Restore the file and line information. */
5952 lineno
= saved_lineno
;
5953 input_filename
= saved_filename
;
5958 /* Substitue into the ARG_TYPES of a function type. */
5961 tsubst_arg_types (arg_types
, args
, complain
, in_decl
)
5967 tree remaining_arg_types
;
5970 if (!arg_types
|| arg_types
== void_list_node
)
5973 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
5974 args
, complain
, in_decl
);
5975 if (remaining_arg_types
== error_mark_node
)
5976 return error_mark_node
;
5978 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
5979 if (type
== error_mark_node
)
5980 return error_mark_node
;
5982 /* Do array-to-pointer, function-to-pointer conversion, and ignore
5983 top-level qualifiers as required. */
5984 type
= TYPE_MAIN_VARIANT (type_decays_to (type
));
5986 /* Note that we do not substitute into default arguments here. The
5987 standard mandates that they be instantiated only when needed,
5988 which is done in build_over_call. */
5989 return hash_tree_cons (TREE_PURPOSE (arg_types
), type
,
5990 remaining_arg_types
);
5994 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
5995 *not* handle the exception-specification for FNTYPE, because the
5996 initial substitution of explicitly provided template parameters
5997 during argument deduction forbids substitution into the
5998 exception-specification:
6002 All references in the function type of the function template to the
6003 corresponding template parameters are replaced by the specified tem-
6004 plate argument values. If a substitution in a template parameter or
6005 in the function type of the function template results in an invalid
6006 type, type deduction fails. [Note: The equivalent substitution in
6007 exception specifications is done only when the function is instanti-
6008 ated, at which point a program is ill-formed if the substitution
6009 results in an invalid type.] */
6012 tsubst_function_type (t
, args
, complain
, in_decl
)
6022 /* The TYPE_CONTEXT is not used for function/method types. */
6023 my_friendly_assert (TYPE_CONTEXT (t
) == NULL_TREE
, 0);
6025 /* Substitue the return type. */
6026 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
6027 if (return_type
== error_mark_node
)
6028 return error_mark_node
;
6030 /* Substitue the argument types. */
6031 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
,
6033 if (arg_types
== error_mark_node
)
6034 return error_mark_node
;
6036 /* Construct a new type node and return it. */
6037 if (TREE_CODE (t
) == FUNCTION_TYPE
)
6038 fntype
= build_function_type (return_type
, arg_types
);
6041 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
6042 if (! IS_AGGR_TYPE (r
))
6046 Type deduction may fail for any of the following
6049 -- Attempting to create "pointer to member of T" when T
6050 is not a class type. */
6052 cp_error ("creating pointer to member function of non-class type `%T'",
6054 return error_mark_node
;
6057 fntype
= build_cplus_method_type (r
, return_type
, TREE_CHAIN
6060 fntype
= build_qualified_type (fntype
, TYPE_QUALS (t
));
6061 fntype
= build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
6066 /* Substitute into the PARMS of a call-declarator. */
6069 tsubst_call_declarator_parms (parms
, args
, complain
, in_decl
)
6079 if (!parms
|| parms
== void_list_node
)
6082 new_parms
= tsubst_call_declarator_parms (TREE_CHAIN (parms
),
6083 args
, complain
, in_decl
);
6085 /* Figure out the type of this parameter. */
6086 type
= tsubst (TREE_VALUE (parms
), args
, complain
, in_decl
);
6088 /* Figure out the default argument as well. Note that we use
6089 tsubst_expr since the default argument is really an expression. */
6090 defarg
= tsubst_expr (TREE_PURPOSE (parms
), args
, complain
, in_decl
);
6092 /* Chain this parameter on to the front of those we have already
6093 processed. We don't use hash_tree_cons because that function
6094 doesn't check TREE_PARMLIST. */
6095 new_parms
= tree_cons (defarg
, type
, new_parms
);
6097 /* And note that these are parameters. */
6098 TREE_PARMLIST (new_parms
) = 1;
6103 /* Take the tree structure T and replace template parameters used
6104 therein with the argument vector ARGS. IN_DECL is an associated
6105 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6106 An appropriate error message is issued only if COMPLAIN is
6107 non-zero. Note that we must be relatively non-tolerant of
6108 extensions here, in order to preserve conformance; if we allow
6109 substitutions that should not be allowed, we may allow argument
6110 deductions that should not succeed, and therefore report ambiguous
6111 overload situations where there are none. In theory, we could
6112 allow the substitution, but indicate that it should have failed,
6113 and allow our caller to make sure that the right thing happens, but
6114 we don't try to do this yet.
6116 This function is used for dealing with types, decls and the like;
6117 for expressions, use tsubst_expr or tsubst_copy. */
6120 tsubst (t
, args
, complain
, in_decl
)
6127 if (t
== NULL_TREE
|| t
== error_mark_node
6128 || t
== integer_type_node
6129 || t
== void_type_node
6130 || t
== char_type_node
6131 || TREE_CODE (t
) == NAMESPACE_DECL
)
6134 if (TREE_CODE (t
) == IDENTIFIER_NODE
)
6135 type
= IDENTIFIER_TYPE_VALUE (t
);
6137 type
= TREE_TYPE (t
);
6138 if (type
== unknown_type_node
)
6139 my_friendly_abort (42);
6141 if (type
&& TREE_CODE (t
) != FUNCTION_DECL
6142 && TREE_CODE (t
) != TYPENAME_TYPE
6143 && TREE_CODE (t
) != TEMPLATE_DECL
6144 && TREE_CODE (t
) != IDENTIFIER_NODE
6145 && TREE_CODE (t
) != FUNCTION_TYPE
6146 && TREE_CODE (t
) != METHOD_TYPE
)
6147 type
= tsubst (type
, args
, complain
, in_decl
);
6148 if (type
== error_mark_node
)
6149 return error_mark_node
;
6151 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'd')
6152 return tsubst_decl (t
, args
, type
, in_decl
);
6154 switch (TREE_CODE (t
))
6159 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
6160 /*entering_scope=*/0);
6163 case IDENTIFIER_NODE
:
6175 if (t
== integer_type_node
)
6178 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
6179 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
6183 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
6185 max
= tsubst_expr (omax
, args
, complain
, in_decl
);
6186 if (max
== error_mark_node
)
6187 return error_mark_node
;
6189 /* See if we can reduce this expression to something simpler. */
6190 max
= maybe_fold_nontype_arg (max
);
6191 if (!processing_template_decl
&& TREE_READONLY_DECL_P (max
))
6192 max
= decl_constant_value (max
);
6194 if (processing_template_decl
6195 /* When providing explicit arguments to a template
6196 function, but leaving some arguments for subsequent
6197 deduction, MAX may be template-dependent even if we're
6198 not PROCESSING_TEMPLATE_DECL. We still need to check for
6199 template parms, though; MAX won't be an INTEGER_CST for
6200 dynamic arrays, either. */
6201 || (TREE_CODE (max
) != INTEGER_CST
6202 && uses_template_parms (max
)))
6204 tree itype
= make_node (INTEGER_TYPE
);
6205 TYPE_MIN_VALUE (itype
) = size_zero_node
;
6206 TYPE_MAX_VALUE (itype
) = build_min (MINUS_EXPR
, sizetype
, max
,
6211 if (integer_zerop (omax
))
6213 /* Still allow an explicit array of size zero. */
6215 pedwarn ("creating array with size zero");
6217 else if (integer_zerop (max
) || INT_CST_LT (max
, integer_zero_node
))
6221 Type deduction may fail for any of the following
6224 Attempting to create an array with a size that is
6225 zero or negative. */
6227 cp_error ("creating array with size zero (`%E')", max
);
6229 return error_mark_node
;
6232 return compute_array_index_type (NULL_TREE
, max
);
6235 case TEMPLATE_TYPE_PARM
:
6236 case TEMPLATE_TEMPLATE_PARM
:
6237 case TEMPLATE_PARM_INDEX
:
6245 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
6246 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
6248 idx
= TEMPLATE_TYPE_IDX (t
);
6249 level
= TEMPLATE_TYPE_LEVEL (t
);
6253 idx
= TEMPLATE_PARM_IDX (t
);
6254 level
= TEMPLATE_PARM_LEVEL (t
);
6257 if (TREE_VEC_LENGTH (args
) > 0)
6259 tree arg
= NULL_TREE
;
6261 levels
= TMPL_ARGS_DEPTH (args
);
6262 if (level
<= levels
)
6263 arg
= TMPL_ARG (args
, level
, idx
);
6265 if (arg
== error_mark_node
)
6266 return error_mark_node
;
6267 else if (arg
!= NULL_TREE
)
6269 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
6271 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (arg
))
6273 return cp_build_qualified_type_real
6274 (arg
, CP_TYPE_QUALS (arg
) | CP_TYPE_QUALS (t
),
6277 else if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
6279 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
6281 /* We are processing a type constructed from
6282 a template template parameter */
6283 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
6284 args
, complain
, in_decl
);
6285 if (argvec
== error_mark_node
)
6286 return error_mark_node
;
6288 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6289 we are resolving nested-types in the signature of
6290 a member function templates.
6291 Otherwise ARG is a TEMPLATE_DECL and is the real
6292 template to be instantiated. */
6293 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
6294 arg
= TYPE_NAME (arg
);
6296 r
= lookup_template_class (DECL_NAME (arg
),
6299 /*entering_scope=*/0);
6300 return cp_build_qualified_type_real (r
,
6305 /* We are processing a template argument list. */
6313 my_friendly_abort (981018);
6316 /* This can happen during the attempted tsubst'ing in
6317 unify. This means that we don't yet have any information
6318 about the template parameter in question. */
6321 /* If we get here, we must have been looking at a parm for a
6322 more deeply nested template. Make a new version of this
6323 template parameter, but with a lower level. */
6324 switch (TREE_CODE (t
))
6326 case TEMPLATE_TYPE_PARM
:
6327 case TEMPLATE_TEMPLATE_PARM
:
6329 TEMPLATE_TYPE_PARM_INDEX (r
)
6330 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
6332 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
6333 TYPE_MAIN_VARIANT (r
) = r
;
6334 TYPE_POINTER_TO (r
) = NULL_TREE
;
6335 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
6337 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
6338 && TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
))
6340 tree argvec
= tsubst (TYPE_TI_ARGS (t
), args
,
6342 if (argvec
== error_mark_node
)
6343 return error_mark_node
;
6345 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
6346 = tree_cons (TYPE_NAME (t
), argvec
, NULL_TREE
);
6350 case TEMPLATE_PARM_INDEX
:
6351 r
= reduce_template_parm_level (t
, type
, levels
);
6355 my_friendly_abort (0);
6363 tree purpose
, value
, chain
, result
;
6365 if (t
== void_list_node
)
6368 purpose
= TREE_PURPOSE (t
);
6371 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
6372 if (purpose
== error_mark_node
)
6373 return error_mark_node
;
6375 value
= TREE_VALUE (t
);
6378 value
= tsubst (value
, args
, complain
, in_decl
);
6379 if (value
== error_mark_node
)
6380 return error_mark_node
;
6382 chain
= TREE_CHAIN (t
);
6383 if (chain
&& chain
!= void_type_node
)
6385 chain
= tsubst (chain
, args
, complain
, in_decl
);
6386 if (chain
== error_mark_node
)
6387 return error_mark_node
;
6389 if (purpose
== TREE_PURPOSE (t
)
6390 && value
== TREE_VALUE (t
)
6391 && chain
== TREE_CHAIN (t
))
6393 result
= hash_tree_cons (purpose
, value
, chain
);
6394 TREE_PARMLIST (result
) = TREE_PARMLIST (t
);
6398 if (type
!= NULL_TREE
)
6400 /* A binfo node. We always need to make a copy, of the node
6401 itself and of its BINFO_BASETYPES. */
6405 /* Make sure type isn't a typedef copy. */
6406 type
= BINFO_TYPE (TYPE_BINFO (type
));
6408 TREE_TYPE (t
) = complete_type (type
);
6409 if (IS_AGGR_TYPE (type
))
6411 BINFO_VTABLE (t
) = TYPE_BINFO_VTABLE (type
);
6412 BINFO_VIRTUALS (t
) = TYPE_BINFO_VIRTUALS (type
);
6413 if (TYPE_BINFO_BASETYPES (type
) != NULL_TREE
)
6414 BINFO_BASETYPES (t
) = copy_node (TYPE_BINFO_BASETYPES (type
));
6419 /* Otherwise, a vector of template arguments. */
6420 return tsubst_template_arg_vector (t
, args
, complain
);
6423 case REFERENCE_TYPE
:
6425 enum tree_code code
;
6427 if (type
== TREE_TYPE (t
))
6430 code
= TREE_CODE (t
);
6435 Type deduction may fail for any of the following
6438 -- Attempting to create a pointer to reference type.
6439 -- Attempting to create a reference to a reference type or
6440 a reference to void. */
6441 if (TREE_CODE (type
) == REFERENCE_TYPE
6442 || (code
== REFERENCE_TYPE
&& TREE_CODE (type
) == VOID_TYPE
))
6444 static int last_line
= 0;
6445 static char* last_file
= 0;
6447 /* We keep track of the last time we issued this error
6448 message to avoid spewing a ton of messages during a
6449 single bad template instantiation. */
6450 if (complain
&& (last_line
!= lineno
||
6451 last_file
!= input_filename
))
6453 if (TREE_CODE (type
) == VOID_TYPE
)
6454 cp_error ("forming reference to void");
6456 cp_error ("forming %s to reference type `%T'",
6457 (code
== POINTER_TYPE
) ? "pointer" : "reference",
6460 last_file
= input_filename
;
6463 return error_mark_node
;
6465 else if (code
== POINTER_TYPE
)
6466 r
= build_pointer_type (type
);
6468 r
= build_reference_type (type
);
6469 r
= cp_build_qualified_type_real (r
, TYPE_QUALS (t
), complain
);
6471 /* Will this ever be needed for TYPE_..._TO values? */
6477 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
6478 if (r
== error_mark_node
|| !IS_AGGR_TYPE (r
))
6482 Type deduction may fail for any of the following
6485 -- Attempting to create "pointer to member of T" when T
6486 is not a class type. */
6488 cp_error ("creating pointer to member of non-class type `%T'",
6490 return error_mark_node
;
6492 return build_offset_type (r
, type
);
6500 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
6501 if (fntype
== error_mark_node
)
6502 return error_mark_node
;
6504 /* Substitue the exception specification. */
6505 raises
= TYPE_RAISES_EXCEPTIONS (t
);
6508 tree list
= NULL_TREE
;
6510 if (! TREE_VALUE (raises
))
6513 for (; raises
!= NULL_TREE
; raises
= TREE_CHAIN (raises
))
6515 tree spec
= TREE_VALUE (raises
);
6517 spec
= tsubst (spec
, args
, complain
, in_decl
);
6518 if (spec
== error_mark_node
)
6520 list
= add_exception_specifier (list
, spec
, complain
);
6522 fntype
= build_exception_variant (fntype
, list
);
6528 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
6529 if (domain
== error_mark_node
)
6530 return error_mark_node
;
6532 /* As an optimization, we avoid regenerating the array type if
6533 it will obviously be the same as T. */
6534 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
6537 /* These checks should match the ones in grokdeclarator.
6541 The deduction may fail for any of the following reasons:
6543 -- Attempting to create an array with an element type that
6544 is void, a function type, or a reference type. */
6545 if (TREE_CODE (type
) == VOID_TYPE
6546 || TREE_CODE (type
) == FUNCTION_TYPE
6547 || TREE_CODE (type
) == REFERENCE_TYPE
)
6550 cp_error ("creating array of `%T'", type
);
6551 return error_mark_node
;
6554 r
= build_cplus_array_type (type
, domain
);
6561 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6563 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
,
6566 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6567 return error_mark_node
;
6569 return fold (build (TREE_CODE (t
), TREE_TYPE (t
), e1
, e2
));
6575 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6577 if (e
== error_mark_node
)
6578 return error_mark_node
;
6580 return fold (build (TREE_CODE (t
), TREE_TYPE (t
), e
));
6585 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
6586 in_decl
, /*entering_scope=*/1);
6587 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
6590 if (ctx
== error_mark_node
|| f
== error_mark_node
)
6591 return error_mark_node
;
6593 if (!IS_AGGR_TYPE (ctx
))
6596 cp_error ("`%T' is not a class, struct, or union type",
6598 return error_mark_node
;
6600 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
6602 /* Normally, make_typename_type does not require that the CTX
6603 have complete type in order to allow things like:
6605 template <class T> struct S { typename S<T>::X Y; };
6607 But, such constructs have already been resolved by this
6608 point, so here CTX really should have complete type, unless
6609 it's a partial instantiation. */
6610 ctx
= complete_type (ctx
);
6611 if (!TYPE_SIZE (ctx
))
6614 incomplete_type_error (NULL_TREE
, ctx
);
6615 return error_mark_node
;
6619 f
= make_typename_type (ctx
, f
, complain
);
6620 if (f
== error_mark_node
)
6622 return cp_build_qualified_type_real (f
,
6624 | CP_TYPE_QUALS (t
),
6630 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6632 if (e
== error_mark_node
)
6633 return error_mark_node
;
6634 return make_pointer_declarator (type
, e
);
6639 tree e
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6641 if (e
== error_mark_node
)
6642 return error_mark_node
;
6643 return make_reference_declarator (type
, e
);
6648 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6650 tree e2
= tsubst_expr (TREE_OPERAND (t
, 1), args
, complain
,
6652 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6653 return error_mark_node
;
6655 return build_parse_node (ARRAY_REF
, e1
, e2
, tsubst_expr
);
6660 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6662 tree e2
= (tsubst_call_declarator_parms
6663 (CALL_DECLARATOR_PARMS (t
), args
, complain
, in_decl
));
6664 tree e3
= tsubst (CALL_DECLARATOR_EXCEPTION_SPEC (t
), args
,
6667 if (e1
== error_mark_node
|| e2
== error_mark_node
6668 || e3
== error_mark_node
)
6669 return error_mark_node
;
6671 return make_call_declarator (e1
, e2
, CALL_DECLARATOR_QUALS (t
), e3
);
6676 tree e1
= tsubst (TREE_OPERAND (t
, 0), args
, complain
,
6678 tree e2
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
6679 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6680 return error_mark_node
;
6682 return build_parse_node (TREE_CODE (t
), e1
, e2
);
6687 tree e1
= tsubst_expr (TYPE_FIELDS (t
), args
, complain
,
6689 if (e1
== error_mark_node
)
6690 return error_mark_node
;
6692 return TREE_TYPE (e1
);
6702 /* This code should match declare_hidden_char_array in
6704 name
= (*decl_printable_name
) (current_function_decl
, 2);
6705 len
= strlen (name
) + 1;
6706 type
= build_array_type (char_type_node
,
6707 build_index_type (build_int_2 (len
, 0)));
6708 str
= build_string (len
, name
);
6709 TREE_TYPE (str
) = type
;
6714 sorry ("use of `%s' in template",
6715 tree_code_name
[(int) TREE_CODE (t
)]);
6716 return error_mark_node
;
6720 /* Like tsubst, but deals with expressions. This function just replaces
6721 template parms; to finish processing the resultant expression, use
6725 tsubst_copy (t
, args
, complain
, in_decl
)
6730 enum tree_code code
;
6733 if (t
== NULL_TREE
|| t
== error_mark_node
)
6736 code
= TREE_CODE (t
);
6741 return do_identifier (DECL_NAME (t
), 0, NULL_TREE
);
6748 if (!DECL_CONTEXT (t
))
6749 /* This is a global enumeration constant. */
6752 /* Unfortunately, we cannot just call lookup_name here.
6755 template <int I> int f() {
6757 struct S { void g() { E e = a; } };
6760 When we instantiate f<7>::S::g(), say, lookup_name is not
6761 clever enough to find f<7>::a. */
6763 = tsubst_aggr_type (TREE_TYPE (t
), args
, complain
, in_decl
,
6764 /*entering_scope=*/0);
6766 for (v
= TYPE_VALUES (enum_type
);
6769 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
6770 return TREE_VALUE (v
);
6772 /* We didn't find the name. That should never happen; if
6773 name-lookup found it during preliminary parsing, we
6774 should find it again here during instantiation. */
6775 my_friendly_abort (0);
6780 if (DECL_CONTEXT (t
))
6784 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
6785 /*entering_scope=*/1);
6786 if (ctx
!= DECL_CONTEXT (t
))
6787 return lookup_field (ctx
, DECL_NAME (t
), 0, 0);
6793 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
6794 t
= tsubst (t
, args
, complain
, in_decl
);
6799 if (is_member_template (t
))
6800 return tsubst (t
, args
, complain
, in_decl
);
6806 /* We must tsbust into a LOOKUP_EXPR in case the names to
6807 which it refers is a conversion operator; in that case the
6808 name will change. We avoid making unnecessary copies,
6811 tree id
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
6813 if (id
!= TREE_OPERAND (t
, 0))
6815 r
= build_nt (LOOKUP_EXPR
, id
);
6816 LOOKUP_EXPR_GLOBAL (r
) = LOOKUP_EXPR_GLOBAL (t
);
6824 case REINTERPRET_CAST_EXPR
:
6825 case CONST_CAST_EXPR
:
6826 case STATIC_CAST_EXPR
:
6827 case DYNAMIC_CAST_EXPR
:
6830 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
6831 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
6834 case PREDECREMENT_EXPR
:
6835 case PREINCREMENT_EXPR
:
6836 case POSTDECREMENT_EXPR
:
6837 case POSTINCREMENT_EXPR
:
6839 case TRUTH_NOT_EXPR
:
6842 case CONVERT_EXPR
: /* Unary + */
6851 (code
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
6852 tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
));
6857 case TRUNC_DIV_EXPR
:
6859 case FLOOR_DIV_EXPR
:
6860 case ROUND_DIV_EXPR
:
6861 case EXACT_DIV_EXPR
:
6863 case BIT_ANDTC_EXPR
:
6866 case TRUNC_MOD_EXPR
:
6867 case FLOOR_MOD_EXPR
:
6868 case TRUTH_ANDIF_EXPR
:
6869 case TRUTH_ORIF_EXPR
:
6870 case TRUTH_AND_EXPR
:
6891 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6892 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
6896 tree fn
= TREE_OPERAND (t
, 0);
6897 if (is_overloaded_fn (fn
))
6898 fn
= tsubst_copy (get_first_fn (fn
), args
, complain
, in_decl
);
6900 /* Sometimes FN is a LOOKUP_EXPR. */
6901 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
6903 (code
, fn
, tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
,
6908 case METHOD_CALL_EXPR
:
6910 tree name
= TREE_OPERAND (t
, 0);
6911 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
6913 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
6915 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
6917 else if (TREE_CODE (name
) == SCOPE_REF
6918 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
6920 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
6922 name
= TREE_OPERAND (name
, 1);
6923 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
6925 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
6926 name
= build_nt (SCOPE_REF
, base
, name
);
6929 name
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
6931 (code
, name
, tsubst_copy (TREE_OPERAND (t
, 1), args
,
6933 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
),
6938 /* This processing should really occur in tsubst_expr, However,
6939 tsubst_expr does not recurse into expressions, since it
6940 assumes that there aren't any statements inside them.
6941 Instead, it simply calls build_expr_from_tree. So, we need
6942 to expand the STMT_EXPR here. */
6943 if (!processing_template_decl
)
6945 tree stmt_expr
= begin_stmt_expr ();
6946 tsubst_expr (STMT_EXPR_STMT (t
), args
,
6948 return finish_stmt_expr (stmt_expr
);
6955 case PSEUDO_DTOR_EXPR
:
6958 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6959 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
6960 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
6967 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6968 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
),
6969 tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
));
6970 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
6977 (code
, tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
),
6978 tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
));
6979 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
6980 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
6984 case TEMPLATE_ID_EXPR
:
6986 /* Substituted template arguments */
6987 tree targs
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
,
6990 if (targs
&& TREE_CODE (targs
) == TREE_LIST
)
6993 for (chain
= targs
; chain
; chain
= TREE_CHAIN (chain
))
6994 TREE_VALUE (chain
) = maybe_fold_nontype_arg (TREE_VALUE (chain
));
6999 for (i
= 0; i
< TREE_VEC_LENGTH (targs
); ++i
)
7000 TREE_VEC_ELT (targs
, i
)
7001 = maybe_fold_nontype_arg (TREE_VEC_ELT (targs
, i
));
7004 return lookup_template_function
7005 (tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
), targs
);
7010 tree purpose
, value
, chain
;
7012 if (t
== void_list_node
)
7015 purpose
= TREE_PURPOSE (t
);
7017 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
7018 value
= TREE_VALUE (t
);
7020 value
= tsubst_copy (value
, args
, complain
, in_decl
);
7021 chain
= TREE_CHAIN (t
);
7022 if (chain
&& chain
!= void_type_node
)
7023 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
7024 if (purpose
== TREE_PURPOSE (t
)
7025 && value
== TREE_VALUE (t
)
7026 && chain
== TREE_CHAIN (t
))
7028 return tree_cons (purpose
, value
, chain
);
7035 case TEMPLATE_TYPE_PARM
:
7036 case TEMPLATE_TEMPLATE_PARM
:
7037 case TEMPLATE_PARM_INDEX
:
7039 case REFERENCE_TYPE
:
7046 return tsubst (t
, args
, complain
, in_decl
);
7048 case IDENTIFIER_NODE
:
7049 if (IDENTIFIER_TYPENAME_P (t
)
7050 /* Make sure it's not just a variable named `__opr', for instance,
7051 which can occur in some existing code. */
7053 return build_typename_overload
7054 (tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
7061 (CONSTRUCTOR
, tsubst (TREE_TYPE (t
), args
, complain
, in_decl
),
7062 NULL_TREE
, tsubst_copy (CONSTRUCTOR_ELTS (t
), args
,
7063 complain
, in_decl
));
7064 TREE_HAS_CONSTRUCTOR (r
) = TREE_HAS_CONSTRUCTOR (t
);
7069 return build_va_arg (tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
,
7071 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
));
7074 return tsubst (t
, args
, complain
, in_decl
);
7081 /* Like tsubst_copy, but also does semantic processing. */
7084 tsubst_expr (t
, args
, complain
, in_decl
)
7091 if (t
== NULL_TREE
|| t
== error_mark_node
)
7094 if (processing_template_decl
)
7095 return tsubst_copy (t
, args
, complain
, in_decl
);
7097 switch (TREE_CODE (t
))
7101 finish_named_return_value
7102 (TREE_OPERAND (t
, 0),
7103 tsubst_expr (TREE_OPERAND (t
, 1), args
, /*complain=*/1, in_decl
));
7104 tsubst_expr (TREE_CHAIN (t
), args
, complain
, in_decl
);
7107 case CTOR_INITIALIZER
:
7109 current_member_init_list
7110 = tsubst_expr_values (TREE_OPERAND (t
, 0), args
);
7111 current_base_init_list
7112 = tsubst_expr_values (TREE_OPERAND (t
, 1), args
);
7114 tsubst_expr (TREE_CHAIN (t
), args
, complain
, in_decl
);
7119 finish_return_stmt (tsubst_expr (RETURN_EXPR (t
),
7120 args
, complain
, in_decl
));
7125 finish_expr_stmt (tsubst_expr (EXPR_STMT_EXPR (t
),
7126 args
, complain
, in_decl
));
7135 decl
= DECL_STMT_DECL (t
);
7136 if (TREE_CODE (decl
) == LABEL_DECL
)
7137 finish_label_decl (DECL_NAME (decl
));
7140 init
= DECL_INITIAL (decl
);
7141 decl
= tsubst (decl
, args
, complain
, in_decl
);
7142 init
= tsubst_expr (init
, args
, complain
, in_decl
);
7144 DECL_INITIAL (decl
) = error_mark_node
;
7145 /* By marking the declaration as instantiated, we avoid
7146 trying to instantiate it. Since instantiate_decl can't
7147 handle local variables, and since we've already done
7148 all that needs to be done, that's the right thing to
7150 if (TREE_CODE (decl
) == VAR_DECL
)
7151 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
7152 maybe_push_decl (decl
);
7153 cp_finish_decl (decl
, init
, NULL_TREE
, 0);
7163 stmt
= begin_for_stmt ();
7164 for (tmp
= FOR_INIT_STMT (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
7165 tsubst_expr (tmp
, args
, complain
, in_decl
);
7166 finish_for_init_stmt (stmt
);
7167 finish_for_cond (tsubst_expr (FOR_COND (t
), args
,
7170 tmp
= tsubst_expr (FOR_EXPR (t
), args
, complain
, in_decl
);
7171 finish_for_expr (tmp
, stmt
);
7172 tsubst_expr (FOR_BODY (t
), args
, complain
, in_decl
);
7173 finish_for_stmt (tmp
, stmt
);
7180 stmt
= begin_while_stmt ();
7181 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t
),
7182 args
, complain
, in_decl
),
7184 tsubst_expr (WHILE_BODY (t
), args
, complain
, in_decl
);
7185 finish_while_stmt (stmt
);
7192 stmt
= begin_do_stmt ();
7193 tsubst_expr (DO_BODY (t
), args
, complain
, in_decl
);
7194 finish_do_body (stmt
);
7195 finish_do_stmt (tsubst_expr (DO_COND (t
), args
,
7206 stmt
= begin_if_stmt ();
7207 finish_if_stmt_cond (tsubst_expr (IF_COND (t
),
7208 args
, complain
, in_decl
),
7211 if (tmp
= THEN_CLAUSE (t
), tmp
)
7213 tsubst_expr (tmp
, args
, complain
, in_decl
);
7214 finish_then_clause (stmt
);
7217 if (tmp
= ELSE_CLAUSE (t
), tmp
)
7219 begin_else_clause ();
7220 tsubst_expr (tmp
, args
, complain
, in_decl
);
7221 finish_else_clause (stmt
);
7233 stmt
= begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
));
7234 for (substmt
= COMPOUND_BODY (t
);
7235 substmt
!= NULL_TREE
;
7236 substmt
= TREE_CHAIN (substmt
))
7237 tsubst_expr (substmt
, args
, complain
, in_decl
);
7238 return finish_compound_stmt (COMPOUND_STMT_NO_SCOPE (t
), stmt
);
7244 finish_break_stmt ();
7249 finish_continue_stmt ();
7257 stmt
= begin_switch_stmt ();
7258 val
= tsubst_expr (SWITCH_COND (t
), args
, complain
, in_decl
);
7259 finish_switch_cond (val
, stmt
);
7260 tsubst_expr (SWITCH_BODY (t
), args
, complain
, in_decl
);
7261 finish_switch_stmt (val
, stmt
);
7267 finish_case_label (tsubst_expr (CASE_LOW (t
), args
, complain
, in_decl
),
7268 tsubst_expr (CASE_HIGH (t
), args
, complain
, in_decl
));
7272 lineno
= STMT_LINENO (t
);
7273 finish_label_stmt (DECL_NAME (LABEL_STMT_LABEL (t
)));
7278 t
= GOTO_DESTINATION (t
);
7279 if (TREE_CODE (t
) != LABEL_DECL
)
7280 /* Computed goto's must be tsubst'd into. On the other hand,
7281 non-computed gotos must not be; the identifier in question
7282 will have no binding. */
7283 t
= tsubst_expr (t
, args
, complain
, in_decl
);
7286 finish_goto_stmt (t
);
7291 finish_asm_stmt (ASM_CV_QUAL (t
),
7292 tsubst_expr (ASM_STRING (t
), args
, complain
, in_decl
),
7293 tsubst_expr (ASM_OUTPUTS (t
), args
, complain
, in_decl
),
7294 tsubst_expr (ASM_INPUTS (t
), args
, complain
, in_decl
),
7295 tsubst_expr (ASM_CLOBBERS (t
), args
, complain
,
7303 stmt
= begin_try_block ();
7304 tsubst_expr (TRY_STMTS (t
), args
, complain
, in_decl
);
7305 finish_cleanup_try_block (stmt
);
7306 finish_cleanup (tsubst_expr (TRY_HANDLERS (t
), args
,
7314 if (FN_TRY_BLOCK_P (t
))
7315 stmt
= begin_function_try_block ();
7317 stmt
= begin_try_block ();
7319 tsubst_expr (TRY_STMTS (t
), args
, complain
, in_decl
);
7321 if (FN_TRY_BLOCK_P (t
))
7322 finish_function_try_block (stmt
);
7324 finish_try_block (stmt
);
7326 handler
= TRY_HANDLERS (t
);
7327 for (; handler
; handler
= TREE_CHAIN (handler
))
7328 tsubst_expr (handler
, args
, complain
, in_decl
);
7329 if (FN_TRY_BLOCK_P (t
))
7330 finish_function_handler_sequence (stmt
);
7332 finish_handler_sequence (stmt
);
7342 stmt
= begin_handler ();
7343 if (HANDLER_PARMS (t
))
7345 decl
= DECL_STMT_DECL (HANDLER_PARMS (t
));
7346 decl
= tsubst (decl
, args
, complain
, in_decl
);
7347 /* Prevent instantiate_decl from trying to instantiate
7348 this variable. We've already done all that needs to be
7350 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
7354 blocks
= finish_handler_parms (decl
, stmt
);
7355 tsubst_expr (HANDLER_BODY (t
), args
, complain
, in_decl
);
7356 finish_handler (blocks
, stmt
);
7363 tsubst (t
, args
, complain
, NULL_TREE
);
7367 return build_expr_from_tree (tsubst_copy (t
, args
, complain
, in_decl
));
7372 /* Instantiate the indicated variable or function template TMPL with
7373 the template arguments in TARG_PTR. */
7376 instantiate_template (tmpl
, targ_ptr
)
7377 tree tmpl
, targ_ptr
;
7385 if (tmpl
== error_mark_node
)
7386 return error_mark_node
;
7388 my_friendly_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
, 283);
7390 /* Check to see if we already have this specialization. */
7391 spec
= retrieve_specialization (tmpl
, targ_ptr
);
7392 if (spec
!= NULL_TREE
)
7395 if (DECL_TEMPLATE_INFO (tmpl
))
7397 /* The TMPL is a partial instantiation. To get a full set of
7398 arguments we must add the arguments used to perform the
7399 partial instantiation. */
7400 targ_ptr
= add_outermost_template_args (DECL_TI_ARGS (tmpl
),
7402 gen_tmpl
= most_general_template (tmpl
);
7404 /* Check to see if we already have this specialization. */
7405 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
);
7406 if (spec
!= NULL_TREE
)
7412 len
= DECL_NTPARMS (gen_tmpl
);
7413 inner_args
= innermost_args (targ_ptr
);
7417 tree t
= TREE_VEC_ELT (inner_args
, i
);
7418 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
7420 tree nt
= target_type (t
);
7421 if (IS_AGGR_TYPE (nt
) && decl_function_context (TYPE_MAIN_DECL (nt
)))
7423 cp_error ("type `%T' composed from a local class is not a valid template-argument", t
);
7424 cp_error (" trying to instantiate `%D'", gen_tmpl
);
7425 fndecl
= error_mark_node
;
7431 /* substitute template parameters */
7432 fndecl
= tsubst (DECL_RESULT (gen_tmpl
), targ_ptr
, /*complain=*/1, gen_tmpl
);
7433 /* The DECL_TI_TEMPLATE should always be the immediate parent
7434 template, not the most general template. */
7435 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
7437 if (flag_external_templates
)
7438 add_pending_template (fndecl
);
7444 /* Push the name of the class template into the scope of the instantiation. */
7447 overload_template_name (type
)
7450 tree id
= DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
));
7453 if (IDENTIFIER_CLASS_VALUE (id
)
7454 && TREE_TYPE (IDENTIFIER_CLASS_VALUE (id
)) == type
)
7457 decl
= build_decl (TYPE_DECL
, id
, type
);
7458 SET_DECL_ARTIFICIAL (decl
);
7459 pushdecl_class_level (decl
);
7462 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
7463 arguments that are being used when calling it. TARGS is a vector
7464 into which the deduced template arguments are placed.
7466 Return zero for success, 2 for an incomplete match that doesn't resolve
7467 all the types, and 1 for complete failure. An error message will be
7468 printed only for an incomplete match.
7470 If FN is a conversion operator, RETURN_TYPE is the type desired as
7471 the result of the conversion operator.
7473 TPARMS is a vector of template parameters.
7475 The EXPLICIT_TARGS are explicit template arguments provided via a
7478 The parameter STRICT is one of:
7481 We are deducing arguments for a function call, as in
7485 We are deducing arguments for a conversion function, as in
7489 We are deducing arguments when calculating the partial
7490 ordering between specializations of function or class
7491 templates, as in [temp.func.order] and [temp.class.order],
7492 when doing an explicit instantiation as in [temp.explicit],
7493 when determining an explicit specialization as in
7494 [temp.expl.spec], or when taking the address of a function
7495 template, as in [temp.deduct.funcaddr].
7497 The other arguments are as for type_unification. */
7500 fn_type_unification (fn
, explicit_targs
, targs
, args
, return_type
,
7502 tree fn
, explicit_targs
, targs
, args
, return_type
;
7503 unification_kind_t strict
;
7509 my_friendly_assert (TREE_CODE (fn
) == TEMPLATE_DECL
, 0);
7511 fntype
= TREE_TYPE (fn
);
7516 The specified template arguments must match the template
7517 parameters in kind (i.e., type, nontype, template), and there
7518 must not be more arguments than there are parameters;
7519 otherwise type deduction fails.
7521 Nontype arguments must match the types of the corresponding
7522 nontype template parameters, or must be convertible to the
7523 types of the corresponding nontype parameters as specified in
7524 _temp.arg.nontype_, otherwise type deduction fails.
7526 All references in the function type of the function template
7527 to the corresponding template parameters are replaced by the
7528 specified template argument values. If a substitution in a
7529 template parameter or in the function type of the function
7530 template results in an invalid type, type deduction fails. */
7532 tree converted_args
;
7535 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
7536 explicit_targs
, NULL_TREE
, /*complain=*/0,
7537 /*require_all_arguments=*/0));
7538 if (converted_args
== error_mark_node
)
7541 fntype
= tsubst (fntype
, converted_args
, /*complain=*/0, NULL_TREE
);
7542 if (fntype
== error_mark_node
)
7545 /* Place the explicitly specified arguments in TARGS. */
7546 for (i
= 0; i
< TREE_VEC_LENGTH (targs
); i
++)
7547 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (converted_args
, i
);
7550 parms
= TYPE_ARG_TYPES (fntype
);
7552 if (DECL_CONV_FN_P (fn
))
7554 /* This is a template conversion operator. Use the return types
7555 as well as the argument types. We use it instead of 'this', since
7556 we could be comparing conversions from different classes. */
7557 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
),
7558 TREE_CHAIN (parms
));
7559 args
= tree_cons (NULL_TREE
, return_type
, TREE_CHAIN (args
));
7562 /* We allow incomplete unification without an error message here
7563 because the standard doesn't seem to explicitly prohibit it. Our
7564 callers must be ready to deal with unification failures in any
7566 result
= type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
7567 targs
, parms
, args
, /*subr=*/0,
7568 strict
, /*allow_incomplete*/1);
7571 /* All is well so far. Now, check:
7575 When all template arguments have been deduced, all uses of
7576 template parameters in nondeduced contexts are replaced with
7577 the corresponding deduced argument values. If the
7578 substitution results in an invalid type, as described above,
7579 type deduction fails. */
7580 if (tsubst (TREE_TYPE (fn
), targs
, /*complain=*/0, NULL_TREE
)
7587 /* Adjust types before performing type deduction, as described in
7588 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
7589 sections are symmetric. PARM is the type of a function parameter
7590 or the return type of the conversion function. ARG is the type of
7591 the argument passed to the call, or the type of the value
7592 intialized with the result of the conversion function. */
7595 maybe_adjust_types_for_deduction (strict
, parm
, arg
)
7596 unification_kind_t strict
;
7607 /* Swap PARM and ARG throughout the remainder of this
7608 function; the handling is precisely symmetric since PARM
7609 will initialize ARG rather than vice versa. */
7617 /* There is nothing to do in this case. */
7621 my_friendly_abort (0);
7624 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
7626 /* [temp.deduct.call]
7628 If P is not a reference type:
7630 --If A is an array type, the pointer type produced by the
7631 array-to-pointer standard conversion (_conv.array_) is
7632 used in place of A for type deduction; otherwise,
7634 --If A is a function type, the pointer type produced by
7635 the function-to-pointer standard conversion
7636 (_conv.func_) is used in place of A for type deduction;
7639 --If A is a cv-qualified type, the top level
7640 cv-qualifiers of A's type are ignored for type
7642 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
7643 *arg
= build_pointer_type (TREE_TYPE (*arg
));
7644 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
7645 *arg
= build_pointer_type (*arg
);
7647 *arg
= TYPE_MAIN_VARIANT (*arg
);
7650 /* [temp.deduct.call]
7652 If P is a cv-qualified type, the top level cv-qualifiers
7653 of P's type are ignored for type deduction. If P is a
7654 reference type, the type referred to by P is used for
7656 *parm
= TYPE_MAIN_VARIANT (*parm
);
7657 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
7658 *parm
= TREE_TYPE (*parm
);
7661 /* Like type_unfication.
7663 If SUBR is 1, we're being called recursively (to unify the
7664 arguments of a function or method parameter of a function
7668 type_unification_real (tparms
, targs
, parms
, args
, subr
,
7669 strict
, allow_incomplete
)
7670 tree tparms
, targs
, parms
, args
;
7672 unification_kind_t strict
;
7673 int allow_incomplete
;
7677 int ntparms
= TREE_VEC_LENGTH (tparms
);
7680 my_friendly_assert (TREE_CODE (tparms
) == TREE_VEC
, 289);
7681 my_friendly_assert (parms
== NULL_TREE
7682 || TREE_CODE (parms
) == TREE_LIST
, 290);
7683 /* ARGS could be NULL (via a call from parse.y to
7684 build_x_function_call). */
7686 my_friendly_assert (TREE_CODE (args
) == TREE_LIST
, 291);
7687 my_friendly_assert (ntparms
> 0, 292);
7692 sub_strict
= UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_DERIVED
;
7696 sub_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
7700 sub_strict
= UNIFY_ALLOW_NONE
;
7704 my_friendly_abort (0);
7708 && parms
!= void_list_node
7710 && args
!= void_list_node
)
7712 parm
= TREE_VALUE (parms
);
7713 parms
= TREE_CHAIN (parms
);
7714 arg
= TREE_VALUE (args
);
7715 args
= TREE_CHAIN (args
);
7717 if (arg
== error_mark_node
)
7719 if (arg
== unknown_type_node
)
7720 /* We can't deduce anything from this, but we might get all the
7721 template args from other function args. */
7724 /* Conversions will be performed on a function argument that
7725 corresponds with a function parameter that contains only
7726 non-deducible template parameters and explicitly specified
7727 template parameters. */
7728 if (! uses_template_parms (parm
))
7732 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7733 type
= TREE_TYPE (arg
);
7740 if (strict
== DEDUCE_EXACT
)
7742 if (same_type_p (parm
, type
))
7746 /* It might work; we shouldn't check now, because we might
7747 get into infinite recursion. Overload resolution will
7754 if (TREE_CODE_CLASS (TREE_CODE (arg
)) != 't')
7756 my_friendly_assert (TREE_TYPE (arg
) != NULL_TREE
, 293);
7757 if (type_unknown_p (arg
))
7759 /* [temp.deduct.type] A template-argument can be deduced from
7760 a pointer to function or pointer to member function
7761 argument if the set of overloaded functions does not
7762 contain function templates and at most one of a set of
7763 overloaded functions provides a unique match. */
7765 if (resolve_overloaded_unification
7766 (tparms
, targs
, parm
, arg
, strict
, sub_strict
)
7771 arg
= TREE_TYPE (arg
);
7775 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7777 switch (unify (tparms
, targs
, parm
, arg
, sub_strict
))
7785 /* Fail if we've reached the end of the parm list, and more args
7786 are present, and the parm list isn't variadic. */
7787 if (args
&& args
!= void_list_node
&& parms
== void_list_node
)
7789 /* Fail if parms are left and they don't have default values. */
7791 && parms
!= void_list_node
7792 && TREE_PURPOSE (parms
) == NULL_TREE
)
7795 for (i
= 0; i
< ntparms
; i
++)
7796 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
7798 if (!allow_incomplete
)
7799 error ("incomplete type unification");
7805 /* Subroutine of type_unification_real. Args are like the variables at the
7806 call site. ARG is an overloaded function (or template-id); we try
7807 deducing template args from each of the overloads, and if only one
7808 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
7811 resolve_overloaded_unification (tparms
, targs
, parm
, arg
, strict
,
7813 tree tparms
, targs
, parm
, arg
;
7814 unification_kind_t strict
;
7817 tree tempargs
= copy_node (targs
);
7820 if (TREE_CODE (arg
) == ADDR_EXPR
)
7821 arg
= TREE_OPERAND (arg
, 0);
7823 if (TREE_CODE (arg
) == COMPONENT_REF
)
7824 /* Handle `&x' where `x' is some static or non-static member
7826 arg
= TREE_OPERAND (arg
, 1);
7828 if (TREE_CODE (arg
) == OFFSET_REF
)
7829 arg
= TREE_OPERAND (arg
, 1);
7831 /* Strip baselink information. */
7832 while (TREE_CODE (arg
) == TREE_LIST
)
7833 arg
= TREE_VALUE (arg
);
7835 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
7837 /* If we got some explicit template args, we need to plug them into
7838 the affected templates before we try to unify, in case the
7839 explicit args will completely resolve the templates in question. */
7841 tree expl_subargs
= TREE_OPERAND (arg
, 1);
7842 arg
= TREE_OPERAND (arg
, 0);
7844 for (; arg
; arg
= OVL_NEXT (arg
))
7846 tree fn
= OVL_CURRENT (arg
);
7849 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7852 subargs
= get_bindings_overload (fn
, DECL_RESULT (fn
), expl_subargs
);
7855 elem
= tsubst (TREE_TYPE (fn
), subargs
, /*complain=*/0,
7857 if (TREE_CODE (elem
) == METHOD_TYPE
)
7858 elem
= build_ptrmemfunc_type (build_pointer_type (elem
));
7859 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
, elem
,
7860 strict
, sub_strict
);
7864 else if (TREE_CODE (arg
) == OVERLOAD
)
7866 for (; arg
; arg
= OVL_NEXT (arg
))
7868 tree type
= TREE_TYPE (OVL_CURRENT (arg
));
7869 if (TREE_CODE (type
) == METHOD_TYPE
)
7870 type
= build_ptrmemfunc_type (build_pointer_type (type
));
7871 good
+= try_one_overload (tparms
, targs
, tempargs
, parm
,
7873 strict
, sub_strict
);
7877 my_friendly_abort (981006);
7879 /* [temp.deduct.type] A template-argument can be deduced from a pointer
7880 to function or pointer to member function argument if the set of
7881 overloaded functions does not contain function templates and at most
7882 one of a set of overloaded functions provides a unique match.
7884 So if we found multiple possibilities, we return success but don't
7889 int i
= TREE_VEC_LENGTH (targs
);
7891 if (TREE_VEC_ELT (tempargs
, i
))
7892 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (tempargs
, i
);
7900 /* Subroutine of resolve_overloaded_unification; does deduction for a single
7901 overload. Fills TARGS with any deduced arguments, or error_mark_node if
7902 different overloads deduce different arguments for a given parm.
7903 Returns 1 on success. */
7906 try_one_overload (tparms
, orig_targs
, targs
, parm
, arg
, strict
,
7908 tree tparms
, orig_targs
, targs
, parm
, arg
;
7909 unification_kind_t strict
;
7916 /* [temp.deduct.type] A template-argument can be deduced from a pointer
7917 to function or pointer to member function argument if the set of
7918 overloaded functions does not contain function templates and at most
7919 one of a set of overloaded functions provides a unique match.
7921 So if this is a template, just return success. */
7923 if (uses_template_parms (arg
))
7926 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
);
7928 /* We don't copy orig_targs for this because if we have already deduced
7929 some template args from previous args, unify would complain when we
7930 try to deduce a template parameter for the same argument, even though
7931 there isn't really a conflict. */
7932 nargs
= TREE_VEC_LENGTH (targs
);
7933 tempargs
= make_tree_vec (nargs
);
7935 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
) != 0)
7938 /* First make sure we didn't deduce anything that conflicts with
7939 explicitly specified args. */
7940 for (i
= nargs
; i
--; )
7942 tree elt
= TREE_VEC_ELT (tempargs
, i
);
7943 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
7945 if (elt
== NULL_TREE
)
7947 else if (uses_template_parms (elt
))
7949 /* Since we're unifying against ourselves, we will fill in template
7950 args used in the function parm list with our own template parms.
7952 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
7955 else if (oldelt
&& ! template_args_equal (oldelt
, elt
))
7959 for (i
= nargs
; i
--; )
7961 tree elt
= TREE_VEC_ELT (tempargs
, i
);
7964 TREE_VEC_ELT (targs
, i
) = elt
;
7970 /* PARM is a template class (perhaps with unbound template
7971 parameters). ARG is a fully instantiated type. If ARG can be
7972 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
7973 TARGS are as for unify. */
7976 try_class_unification (tparms
, targs
, parm
, arg
)
7985 if (!CLASSTYPE_TEMPLATE_INFO (arg
)
7986 || CLASSTYPE_TI_TEMPLATE (arg
) != CLASSTYPE_TI_TEMPLATE (parm
))
7989 /* We need to make a new template argument vector for the call to
7990 unify. If we used TARGS, we'd clutter it up with the result of
7991 the attempted unification, even if this class didn't work out.
7992 We also don't want to commit ourselves to all the unifications
7993 we've already done, since unification is supposed to be done on
7994 an argument-by-argument basis. In other words, consider the
7995 following pathological case:
7997 template <int I, int J, int K>
8000 template <int I, int J>
8001 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
8003 template <int I, int J, int K>
8004 void f(S<I, J, K>, S<I, I, I>);
8013 Now, by the time we consider the unification involving `s2', we
8014 already know that we must have `f<0, 0, 0>'. But, even though
8015 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is not legal
8016 because there are two ways to unify base classes of S<0, 1, 2>
8017 with S<I, I, I>. If we kept the already deduced knowledge, we
8018 would reject the possibility I=1. */
8019 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
8020 i
= unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
8021 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
);
8023 /* If unification failed, we're done. */
8030 /* Subroutine of get_template_base. RVAL, if non-NULL, is a base we
8031 have alreay discovered to be satisfactory. ARG_BINFO is the binfo
8032 for the base class of ARG that we are currently examining. */
8035 get_template_base_recursive (tparms
, targs
, parm
,
8036 arg_binfo
, rval
, flags
)
8046 tree arg
= BINFO_TYPE (arg_binfo
);
8048 if (!(flags
& GTB_IGNORE_TYPE
))
8050 tree r
= try_class_unification (tparms
, targs
,
8053 /* If there is more than one satisfactory baseclass, then:
8057 If they yield more than one possible deduced A, the type
8061 if (r
&& rval
&& !same_type_p (r
, rval
))
8062 return error_mark_node
;
8067 binfos
= BINFO_BASETYPES (arg_binfo
);
8068 n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
8070 /* Process base types. */
8071 for (i
= 0; i
< n_baselinks
; i
++)
8073 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
8076 /* Skip this base, if we've already seen it. */
8077 if (BINFO_MARKED (base_binfo
))
8081 (flags
& GTB_VIA_VIRTUAL
) || TREE_VIA_VIRTUAL (base_binfo
);
8083 /* When searching for a non-virtual, we cannot mark virtually
8086 SET_BINFO_MARKED (base_binfo
);
8088 rval
= get_template_base_recursive (tparms
, targs
,
8092 GTB_VIA_VIRTUAL
* this_virtual
);
8094 /* If we discovered more than one matching base class, we can
8096 if (rval
== error_mark_node
)
8097 return error_mark_node
;
8103 /* Given a template type PARM and a class type ARG, find the unique
8104 base type in ARG that is an instance of PARM. We do not examine
8105 ARG itself; only its base-classes. If there is no appropriate base
8106 class, return NULL_TREE. If there is more than one, return
8107 error_mark_node. PARM may be the type of a partial specialization,
8108 as well as a plain template type. Used by unify. */
8111 get_template_base (tparms
, targs
, parm
, arg
)
8120 my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg
)), 92);
8122 arg_binfo
= TYPE_BINFO (complete_type (arg
));
8123 rval
= get_template_base_recursive (tparms
, targs
,
8128 /* Since get_template_base_recursive marks the bases classes, we
8129 must unmark them here. */
8130 dfs_walk (arg_binfo
, dfs_unmark
, markedp
, 0);
8135 /* Returns the level of DECL, which declares a template parameter. */
8138 template_decl_level (decl
)
8141 switch (TREE_CODE (decl
))
8145 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
8148 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
8151 my_friendly_abort (0);
8156 /* Decide whether ARG can be unified with PARM, considering only the
8157 cv-qualifiers of each type, given STRICT as documented for unify.
8158 Returns non-zero iff the unification is OK on that basis.*/
8161 check_cv_quals_for_unify (strict
, arg
, parm
)
8166 if (!(strict
& UNIFY_ALLOW_MORE_CV_QUAL
)
8167 && !at_least_as_qualified_p (arg
, parm
))
8170 if (!(strict
& UNIFY_ALLOW_LESS_CV_QUAL
)
8171 && !at_least_as_qualified_p (parm
, arg
))
8177 /* Takes parameters as for type_unification. Returns 0 if the
8178 type deduction suceeds, 1 otherwise. The parameter STRICT is a
8179 bitwise or of the following flags:
8182 Require an exact match between PARM and ARG.
8183 UNIFY_ALLOW_MORE_CV_QUAL:
8184 Allow the deduced ARG to be more cv-qualified than ARG.
8185 UNIFY_ALLOW_LESS_CV_QUAL:
8186 Allow the deduced ARG to be less cv-qualified than ARG.
8187 UNIFY_ALLOW_DERIVED:
8188 Allow the deduced ARG to be a template base class of ARG,
8189 or a pointer to a template base class of the type pointed to by
8191 UNIFY_ALLOW_INTEGER:
8192 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
8193 case for more information. */
8196 unify (tparms
, targs
, parm
, arg
, strict
)
8197 tree tparms
, targs
, parm
, arg
;
8204 /* I don't think this will do the right thing with respect to types.
8205 But the only case I've seen it in so far has been array bounds, where
8206 signedness is the only information lost, and I think that will be
8208 while (TREE_CODE (parm
) == NOP_EXPR
)
8209 parm
= TREE_OPERAND (parm
, 0);
8211 if (arg
== error_mark_node
)
8213 if (arg
== unknown_type_node
)
8214 /* We can't deduce anything from this, but we might get all the
8215 template args from other function args. */
8218 /* If PARM uses template parameters, then we can't bail out here,
8219 even if ARG == PARM, since we won't record unifications for the
8220 template parameters. We might need them if we're trying to
8221 figure out which of two things is more specialized. */
8222 if (arg
== parm
&& !uses_template_parms (parm
))
8225 /* Immediately reject some pairs that won't unify because of
8226 cv-qualification mismatches. */
8227 if (TREE_CODE (arg
) == TREE_CODE (parm
)
8228 && TREE_CODE_CLASS (TREE_CODE (arg
)) == 't'
8229 /* We check the cv-qualifiers when unifying with template type
8230 parameters below. We want to allow ARG `const T' to unify with
8231 PARM `T' for example, when computing which of two templates
8232 is more specialized, for example. */
8233 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
8234 && !check_cv_quals_for_unify (strict
, arg
, parm
))
8237 switch (TREE_CODE (parm
))
8240 /* In a type which contains a nested-name-specifier, template
8241 argument values cannot be deduced for template parameters used
8242 within the nested-name-specifier. */
8245 case TEMPLATE_TYPE_PARM
:
8246 case TEMPLATE_TEMPLATE_PARM
:
8247 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
8249 if (TEMPLATE_TYPE_LEVEL (parm
)
8250 != template_decl_level (tparm
))
8251 /* The PARM is not one we're trying to unify. Just check
8252 to see if it matches ARG. */
8253 return (TREE_CODE (arg
) == TREE_CODE (parm
)
8254 && same_type_p (parm
, arg
)) ? 0 : 1;
8255 idx
= TEMPLATE_TYPE_IDX (parm
);
8256 targ
= TREE_VEC_ELT (targs
, idx
);
8257 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
8259 /* Check for mixed types and values. */
8260 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
8261 && TREE_CODE (tparm
) != TYPE_DECL
)
8262 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
8263 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
8266 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
8268 if (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
))
8270 /* We arrive here when PARM does not involve template
8273 /* ARG must be constructed from a template class. */
8274 if (TREE_CODE (arg
) != RECORD_TYPE
|| !CLASSTYPE_TEMPLATE_INFO (arg
))
8278 tree parmtmpl
= TYPE_TI_TEMPLATE (parm
);
8279 tree parmvec
= TYPE_TI_ARGS (parm
);
8280 tree argvec
= CLASSTYPE_TI_ARGS (arg
);
8282 = DECL_INNERMOST_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (arg
));
8285 /* The parameter and argument roles have to be switched here
8286 in order to handle default arguments properly. For example,
8287 template<template <class> class TT> void f(TT<int>)
8288 should be able to accept vector<int> which comes from
8289 template <class T, class Allocator = allocator>
8292 if (coerce_template_parms (argtmplvec
, parmvec
, parmtmpl
, 0, 1)
8296 /* Deduce arguments T, i from TT<T> or TT<i>.
8297 We check each element of PARMVEC and ARGVEC individually
8298 rather than the whole TREE_VEC since they can have
8299 different number of elements. */
8301 for (i
= 0; i
< TREE_VEC_LENGTH (parmvec
); ++i
)
8303 tree t
= TREE_VEC_ELT (parmvec
, i
);
8305 if (unify (tparms
, targs
, t
,
8306 TREE_VEC_ELT (argvec
, i
),
8311 arg
= CLASSTYPE_TI_TEMPLATE (arg
);
8316 /* If PARM is `const T' and ARG is only `int', we don't have
8317 a match unless we are allowing additional qualification.
8318 If ARG is `const int' and PARM is just `T' that's OK;
8319 that binds `const int' to `T'. */
8320 if (!check_cv_quals_for_unify (strict
| UNIFY_ALLOW_LESS_CV_QUAL
,
8324 /* Consider the case where ARG is `const volatile int' and
8325 PARM is `const T'. Then, T should be `volatile int'. */
8327 cp_build_qualified_type_real (arg
,
8329 & ~CP_TYPE_QUALS (parm
),
8331 if (arg
== error_mark_node
)
8335 /* Simple cases: Value already set, does match or doesn't. */
8336 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
8341 /* Make sure that ARG is not a variable-sized array. (Note that
8342 were talking about variable-sized arrays (like `int[n]'),
8343 rather than arrays of unknown size (like `int[]').) We'll
8344 get very confused by such a type since the bound of the array
8345 will not be computable in an instantiation. Besides, such
8346 types are not allowed in ISO C++, so we can do as we please
8348 if (TREE_CODE (arg
) == ARRAY_TYPE
8349 && !uses_template_parms (arg
)
8350 && (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (arg
)))
8354 TREE_VEC_ELT (targs
, idx
) = arg
;
8357 case TEMPLATE_PARM_INDEX
:
8358 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
8360 if (TEMPLATE_PARM_LEVEL (parm
)
8361 != template_decl_level (tparm
))
8362 /* The PARM is not one we're trying to unify. Just check
8363 to see if it matches ARG. */
8364 return (TREE_CODE (arg
) == TREE_CODE (parm
)
8365 && cp_tree_equal (parm
, arg
) > 0) ? 0 : 1;
8367 idx
= TEMPLATE_PARM_IDX (parm
);
8368 targ
= TREE_VEC_ELT (targs
, idx
);
8372 int i
= (cp_tree_equal (targ
, arg
) > 0);
8378 my_friendly_abort (42);
8381 /* [temp.deduct.type] If, in the declaration of a function template
8382 with a non-type template-parameter, the non-type
8383 template-parameter is used in an expression in the function
8384 parameter-list and, if the corresponding template-argument is
8385 deduced, the template-argument type shall match the type of the
8386 template-parameter exactly, except that a template-argument
8387 deduced from an array bound may be of any integral type. */
8388 if (same_type_p (TREE_TYPE (arg
), TREE_TYPE (parm
)))
8390 else if ((strict
& UNIFY_ALLOW_INTEGER
)
8391 && (TREE_CODE (TREE_TYPE (parm
)) == INTEGER_TYPE
8392 || TREE_CODE (TREE_TYPE (parm
)) == BOOLEAN_TYPE
))
8397 TREE_VEC_ELT (targs
, idx
) = arg
;
8404 if (TREE_CODE (arg
) != POINTER_TYPE
)
8407 /* [temp.deduct.call]
8409 A can be another pointer or pointer to member type that can
8410 be converted to the deduced A via a qualification
8411 conversion (_conv.qual_).
8413 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
8414 This will allow for additional cv-qualification of the
8415 pointed-to types if appropriate. In general, this is a bit
8416 too generous; we are only supposed to allow qualification
8417 conversions and this method will allow an ARG of char** and
8418 a deduced ARG of const char**. However, overload
8419 resolution will subsequently invalidate the candidate, so
8420 this is probably OK. */
8421 sub_strict
= strict
;
8423 if (TREE_CODE (TREE_TYPE (arg
)) != RECORD_TYPE
)
8424 /* The derived-to-base conversion only persists through one
8425 level of pointers. */
8426 sub_strict
&= ~UNIFY_ALLOW_DERIVED
;
8428 return unify (tparms
, targs
, TREE_TYPE (parm
),
8429 TREE_TYPE (arg
), sub_strict
);
8432 case REFERENCE_TYPE
:
8433 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
8435 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8439 if (TREE_CODE (arg
) != ARRAY_TYPE
)
8441 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
8442 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
8444 if (TYPE_DOMAIN (parm
) != NULL_TREE
8445 && unify (tparms
, targs
, TYPE_DOMAIN (parm
),
8446 TYPE_DOMAIN (arg
), UNIFY_ALLOW_NONE
) != 0)
8448 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8456 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8459 if (TREE_CODE (parm
) == INTEGER_TYPE
8460 && TREE_CODE (TYPE_MAX_VALUE (parm
)) != INTEGER_CST
)
8462 if (TYPE_MIN_VALUE (parm
) && TYPE_MIN_VALUE (arg
)
8463 && unify (tparms
, targs
, TYPE_MIN_VALUE (parm
),
8464 TYPE_MIN_VALUE (arg
), UNIFY_ALLOW_INTEGER
))
8466 if (TYPE_MAX_VALUE (parm
) && TYPE_MAX_VALUE (arg
)
8467 && unify (tparms
, targs
, TYPE_MAX_VALUE (parm
),
8468 TYPE_MAX_VALUE (arg
), UNIFY_ALLOW_INTEGER
))
8471 /* We use the TYPE_MAIN_VARIANT since we have already
8472 checked cv-qualification at the top of the
8474 else if (!same_type_p (TYPE_MAIN_VARIANT (arg
),
8475 TYPE_MAIN_VARIANT (parm
)))
8478 /* As far as unification is concerned, this wins. Later checks
8479 will invalidate it if necessary. */
8482 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
8483 /* Type INTEGER_CST can come from ordinary constant template args. */
8485 while (TREE_CODE (arg
) == NOP_EXPR
)
8486 arg
= TREE_OPERAND (arg
, 0);
8488 if (TREE_CODE (arg
) != INTEGER_CST
)
8490 return !tree_int_cst_equal (parm
, arg
);
8495 if (TREE_CODE (arg
) != TREE_VEC
)
8497 if (TREE_VEC_LENGTH (parm
) != TREE_VEC_LENGTH (arg
))
8499 for (i
= TREE_VEC_LENGTH (parm
) - 1; i
>= 0; i
--)
8500 if (unify (tparms
, targs
,
8501 TREE_VEC_ELT (parm
, i
), TREE_VEC_ELT (arg
, i
),
8509 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8512 if (TYPE_PTRMEMFUNC_P (parm
))
8514 if (!TYPE_PTRMEMFUNC_P (arg
))
8517 return unify (tparms
, targs
,
8518 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
8519 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
8523 if (CLASSTYPE_TEMPLATE_INFO (parm
))
8527 if (strict
& UNIFY_ALLOW_DERIVED
)
8529 /* First, we try to unify the PARM and ARG directly. */
8530 t
= try_class_unification (tparms
, targs
,
8535 /* Fallback to the special case allowed in
8538 If P is a class, and P has the form
8539 template-id, then A can be a derived class of
8540 the deduced A. Likewise, if P is a pointer to
8541 a class of the form template-id, A can be a
8542 pointer to a derived class pointed to by the
8544 t
= get_template_base (tparms
, targs
,
8547 if (! t
|| t
== error_mark_node
)
8551 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
8552 && (CLASSTYPE_TI_TEMPLATE (parm
)
8553 == CLASSTYPE_TI_TEMPLATE (arg
)))
8554 /* Perhaps PARM is something like S<U> and ARG is S<int>.
8555 Then, we should unify `int' and `U'. */
8558 /* There's no chance of unication succeeding. */
8561 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
8562 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
);
8564 else if (!same_type_p (TYPE_MAIN_VARIANT (parm
),
8565 TYPE_MAIN_VARIANT (arg
)))
8571 if (TREE_CODE (arg
) != TREE_CODE (parm
))
8574 if (unify (tparms
, targs
, TREE_TYPE (parm
),
8575 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
))
8577 return type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
8578 TYPE_ARG_TYPES (arg
), 1,
8582 if (TREE_CODE (arg
) != OFFSET_TYPE
)
8584 if (unify (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
8585 TYPE_OFFSET_BASETYPE (arg
), UNIFY_ALLOW_NONE
))
8587 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
8591 if (arg
!= decl_constant_value (parm
))
8596 /* Matched cases are handled by the ARG == PARM test above. */
8600 if (TREE_CODE (TREE_OPERAND (parm
, 1)) == INTEGER_CST
)
8602 /* We handle this case specially, since it comes up with
8603 arrays. In particular, something like:
8605 template <int N> void f(int (&x)[N]);
8607 Here, we are trying to unify the range type, which
8608 looks like [0 ... (N - 1)]. */
8610 t1
= TREE_OPERAND (parm
, 0);
8611 t2
= TREE_OPERAND (parm
, 1);
8613 /* Should this be a regular fold? */
8614 t
= maybe_fold_nontype_arg (build (PLUS_EXPR
,
8618 return unify (tparms
, targs
, t1
, t
, strict
);
8620 /* else fall through */
8623 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm
))))
8624 /* We're looking at an expression. This can happen with
8628 void foo(S<I>, S<I + 2>);
8630 This is a "nondeduced context":
8634 The nondeduced contexts are:
8636 --A type that is a template-id in which one or more of
8637 the template-arguments is an expression that references
8638 a template-parameter.
8640 In these cases, we assume deduction succeeded, but don't
8641 actually infer any unifications. */
8644 sorry ("use of `%s' in template type unification",
8645 tree_code_name
[(int) TREE_CODE (parm
)]);
8651 /* Called if RESULT is explicitly instantiated, or is a member of an
8652 explicitly instantiated class, or if using -frepo and the
8653 instantiation of RESULT has been assigned to this file. */
8656 mark_decl_instantiated (result
, extern_p
)
8660 if (TREE_CODE (result
) != FUNCTION_DECL
)
8661 /* The TREE_PUBLIC flag for function declarations will have been
8662 set correctly by tsubst. */
8663 TREE_PUBLIC (result
) = 1;
8667 DECL_INTERFACE_KNOWN (result
) = 1;
8668 DECL_NOT_REALLY_EXTERN (result
) = 1;
8670 /* Always make artificials weak. */
8671 if (DECL_ARTIFICIAL (result
) && flag_weak
)
8672 comdat_linkage (result
);
8673 /* For WIN32 we also want to put explicit instantiations in
8674 linkonce sections. */
8675 else if (TREE_PUBLIC (result
))
8676 maybe_make_one_only (result
);
8678 else if (TREE_CODE (result
) == FUNCTION_DECL
)
8679 mark_inline_for_output (result
);
8682 /* Given two function templates PAT1 and PAT2, and explicit template
8683 arguments EXPLICIT_ARGS return:
8685 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
8686 -1 if PAT2 is more specialized than PAT1.
8687 0 if neither is more specialized. */
8690 more_specialized (pat1
, pat2
, explicit_args
)
8691 tree pat1
, pat2
, explicit_args
;
8696 targs
= get_bindings_overload (pat1
, DECL_RESULT (pat2
), explicit_args
);
8700 targs
= get_bindings_overload (pat2
, DECL_RESULT (pat1
), explicit_args
);
8707 /* Given two class template specialization list nodes PAT1 and PAT2, return:
8709 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
8710 -1 if PAT2 is more specialized than PAT1.
8711 0 if neither is more specialized. */
8714 more_specialized_class (pat1
, pat2
)
8720 targs
= get_class_bindings (TREE_VALUE (pat1
), TREE_PURPOSE (pat1
),
8721 TREE_PURPOSE (pat2
));
8725 targs
= get_class_bindings (TREE_VALUE (pat2
), TREE_PURPOSE (pat2
),
8726 TREE_PURPOSE (pat1
));
8733 /* Return the template arguments that will produce the function signature
8734 DECL from the function template FN, with the explicit template
8735 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
8736 also match. Return NULL_TREE if no satisfactory arguments could be
8740 get_bindings_real (fn
, decl
, explicit_args
, check_rettype
)
8741 tree fn
, decl
, explicit_args
;
8744 int ntparms
= DECL_NTPARMS (fn
);
8745 tree targs
= make_tree_vec (ntparms
);
8747 tree decl_arg_types
;
8750 /* Substitute the explicit template arguments into the type of DECL.
8751 The call to fn_type_unification will handle substitution into the
8753 decl_type
= TREE_TYPE (decl
);
8754 if (explicit_args
&& uses_template_parms (decl_type
))
8757 tree converted_args
;
8759 if (DECL_TEMPLATE_INFO (decl
))
8760 tmpl
= DECL_TI_TEMPLATE (decl
);
8762 /* We can get here for some illegal specializations. */
8766 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
8767 explicit_args
, NULL_TREE
,
8769 /*require_all_arguments=*/0));
8770 if (converted_args
== error_mark_node
)
8773 decl_type
= tsubst (decl_type
, converted_args
, /*complain=*/0,
8775 if (decl_type
== error_mark_node
)
8779 /* If FN is a static member function, adjust the type of DECL
8781 decl_arg_types
= TYPE_ARG_TYPES (decl_type
);
8782 if (DECL_STATIC_FUNCTION_P (fn
)
8783 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
8784 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
8786 i
= fn_type_unification (fn
, explicit_args
, targs
,
8788 TREE_TYPE (decl_type
),
8796 /* Check to see that the resulting return type is also OK. */
8797 tree t
= tsubst (TREE_TYPE (TREE_TYPE (fn
)), targs
,
8798 /*complain=*/0, NULL_TREE
);
8800 if (!same_type_p (t
, TREE_TYPE (TREE_TYPE (decl
))))
8807 /* For most uses, we want to check the return type. */
8810 get_bindings (fn
, decl
, explicit_args
)
8811 tree fn
, decl
, explicit_args
;
8813 return get_bindings_real (fn
, decl
, explicit_args
, 1);
8816 /* But for more_specialized, we only care about the parameter types. */
8819 get_bindings_overload (fn
, decl
, explicit_args
)
8820 tree fn
, decl
, explicit_args
;
8822 return get_bindings_real (fn
, decl
, explicit_args
, 0);
8825 /* Return the innermost template arguments that, when applied to a
8826 template specialization whose innermost template parameters are
8827 TPARMS, and whose specialization arguments are ARGS, yield the
8830 For example, suppose we have:
8832 template <class T, class U> struct S {};
8833 template <class T> struct S<T*, int> {};
8835 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
8836 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
8837 int}. The resulting vector will be {double}, indicating that `T'
8838 is bound to `double'. */
8841 get_class_bindings (tparms
, parms
, args
)
8842 tree tparms
, parms
, args
;
8844 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
8845 tree vec
= make_tree_vec (ntparms
);
8847 args
= innermost_args (args
);
8849 if (unify (tparms
, vec
, parms
, args
, UNIFY_ALLOW_NONE
))
8852 for (i
= 0; i
< ntparms
; ++i
)
8853 if (! TREE_VEC_ELT (vec
, i
))
8859 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
8860 Pick the most specialized template, and return the corresponding
8861 instantiation, or if there is no corresponding instantiation, the
8862 template itself. EXPLICIT_ARGS is any template arguments explicity
8863 mentioned in a template-id. If there is no most specialized
8864 tempalte, error_mark_node is returned. If there are no templates
8865 at all, NULL_TREE is returned. */
8868 most_specialized_instantiation (instantiations
, explicit_args
)
8869 tree instantiations
;
8875 if (!instantiations
)
8878 champ
= instantiations
;
8879 for (fn
= TREE_CHAIN (instantiations
); fn
; fn
= TREE_CHAIN (fn
))
8881 fate
= more_specialized (TREE_VALUE (champ
),
8882 TREE_VALUE (fn
), explicit_args
);
8889 fn
= TREE_CHAIN (fn
);
8891 return error_mark_node
;
8897 for (fn
= instantiations
; fn
&& fn
!= champ
; fn
= TREE_CHAIN (fn
))
8899 fate
= more_specialized (TREE_VALUE (champ
),
8900 TREE_VALUE (fn
), explicit_args
);
8902 return error_mark_node
;
8905 return TREE_PURPOSE (champ
) ? TREE_PURPOSE (champ
) : TREE_VALUE (champ
);
8908 /* Return the most specialized of the list of templates in FNS that can
8909 produce an instantiation matching DECL, given the explicit template
8910 arguments EXPLICIT_ARGS. */
8913 most_specialized (fns
, decl
, explicit_args
)
8914 tree fns
, decl
, explicit_args
;
8916 tree candidates
= NULL_TREE
;
8919 for (fn
= fns
; fn
; fn
= TREE_CHAIN (fn
))
8921 tree candidate
= TREE_VALUE (fn
);
8923 args
= get_bindings (candidate
, decl
, explicit_args
);
8925 candidates
= tree_cons (NULL_TREE
, candidate
, candidates
);
8928 return most_specialized_instantiation (candidates
, explicit_args
);
8931 /* If DECL is a specialization of some template, return the most
8932 general such template. For example, given:
8934 template <class T> struct S { template <class U> void f(U); };
8936 if TMPL is `template <class U> void S<int>::f(U)' this will return
8937 the full template. This function will not trace past partial
8938 specializations, however. For example, given in addition:
8940 template <class T> struct S<T*> { template <class U> void f(U); };
8942 if TMPL is `template <class U> void S<int*>::f(U)' this will return
8943 `template <class T> template <class U> S<T*>::f(U)'. */
8946 most_general_template (decl
)
8949 while (DECL_TEMPLATE_INFO (decl
)
8950 /* The DECL_TI_TEMPLATE can be a LOOKUP_EXPR or
8951 IDENTIFIER_NODE in some cases. (See cp-tree.h for
8953 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) == TEMPLATE_DECL
)
8954 decl
= DECL_TI_TEMPLATE (decl
);
8959 /* Return the most specialized of the class template specializations
8960 of TMPL which can produce an instantiation matching ARGS, or
8961 error_mark_node if the choice is ambiguous. */
8964 most_specialized_class (tmpl
, args
)
8968 tree list
= NULL_TREE
;
8973 tmpl
= most_general_template (tmpl
);
8974 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
); t
; t
= TREE_CHAIN (t
))
8977 = get_class_bindings (TREE_VALUE (t
), TREE_PURPOSE (t
), args
);
8980 list
= decl_tree_cons (TREE_PURPOSE (t
), TREE_VALUE (t
), list
);
8981 TREE_TYPE (list
) = TREE_TYPE (t
);
8991 for (; t
; t
= TREE_CHAIN (t
))
8993 fate
= more_specialized_class (champ
, t
);
9002 return error_mark_node
;
9008 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
9010 fate
= more_specialized_class (champ
, t
);
9012 return error_mark_node
;
9018 /* called from the parser. */
9021 do_decl_instantiation (declspecs
, declarator
, storage
)
9022 tree declspecs
, declarator
, storage
;
9024 tree decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, 0, NULL_TREE
);
9025 tree result
= NULL_TREE
;
9029 /* An error ocurred, for which grokdeclarator has already issued
9030 an appropriate message. */
9032 else if (! DECL_LANG_SPECIFIC (decl
))
9034 cp_error ("explicit instantiation of non-template `%#D'", decl
);
9037 else if (TREE_CODE (decl
) == VAR_DECL
)
9039 /* There is an asymmetry here in the way VAR_DECLs and
9040 FUNCTION_DECLs are handled by grokdeclarator. In the case of
9041 the latter, the DECL we get back will be marked as a
9042 template instantiation, and the appropriate
9043 DECL_TEMPLATE_INFO will be set up. This does not happen for
9044 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
9045 should handle VAR_DECLs as it currently handles
9047 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, 0);
9048 if (result
&& TREE_CODE (result
) != VAR_DECL
)
9050 cp_error ("no matching template for `%D' found", result
);
9054 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
9056 cp_error ("explicit instantiation of `%#D'", decl
);
9062 /* Check for various error cases. Note that if the explicit
9063 instantiation is legal the RESULT will currently be marked as an
9064 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
9065 until we get here. */
9067 if (DECL_TEMPLATE_SPECIALIZATION (result
))
9071 No program shall both explicitly instantiate and explicitly
9072 specialize a template. */
9073 cp_pedwarn ("explicit instantiation of `%#D' after", result
);
9074 cp_pedwarn_at ("explicit specialization here", result
);
9077 else if (DECL_EXPLICIT_INSTANTIATION (result
))
9081 No program shall explicitly instantiate any template more
9084 We check DECL_INTERFACE_KNOWN so as not to complain when the first
9085 instantiation was `extern' and the second is not, and EXTERN_P for
9086 the opposite case. If -frepo, chances are we already got marked
9087 as an explicit instantion because of the repo file. */
9088 if (DECL_INTERFACE_KNOWN (result
) && !extern_p
&& !flag_use_repository
)
9089 cp_pedwarn ("duplicate explicit instantiation of `%#D'", result
);
9091 /* If we've already instantiated the template, just return now. */
9092 if (DECL_INTERFACE_KNOWN (result
))
9095 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
9097 cp_error ("no matching template for `%D' found", result
);
9100 else if (!DECL_TEMPLATE_INFO (result
))
9102 cp_pedwarn ("explicit instantiation of non-template `%#D'", result
);
9106 if (flag_external_templates
)
9109 if (storage
== NULL_TREE
)
9111 else if (storage
== ridpointers
[(int) RID_EXTERN
])
9114 cp_pedwarn ("ANSI C++ forbids the use of `extern' on explicit instantiations");
9118 cp_error ("storage class `%D' applied to template instantiation",
9121 SET_DECL_EXPLICIT_INSTANTIATION (result
);
9122 mark_decl_instantiated (result
, extern_p
);
9123 repo_template_instantiated (result
, extern_p
);
9125 instantiate_decl (result
);
9129 mark_class_instantiated (t
, extern_p
)
9133 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
9134 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
9135 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
9136 CLASSTYPE_VTABLE_NEEDS_WRITING (t
) = ! extern_p
;
9137 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
9140 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
9141 rest_of_type_compilation (t
, 1);
9146 do_type_instantiation (t
, storage
)
9153 if (TREE_CODE (t
) == TYPE_DECL
)
9156 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
9158 cp_error ("explicit instantiation of non-template type `%T'", t
);
9164 /* With -fexternal-templates, explicit instantiations are treated the same
9165 as implicit ones. */
9166 if (flag_external_templates
)
9169 if (TYPE_SIZE (t
) == NULL_TREE
)
9171 cp_error ("explicit instantiation of `%#T' before definition of template",
9176 if (storage
!= NULL_TREE
)
9179 cp_pedwarn("ANSI C++ forbids the use of `%s' on explicit instantiations",
9180 IDENTIFIER_POINTER (storage
));
9182 if (storage
== ridpointers
[(int) RID_INLINE
])
9184 else if (storage
== ridpointers
[(int) RID_EXTERN
])
9186 else if (storage
== ridpointers
[(int) RID_STATIC
])
9190 cp_error ("storage class `%D' applied to template instantiation",
9196 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
9200 No program shall both explicitly instantiate and explicitly
9201 specialize a template. */
9202 cp_error ("explicit instantiation of `%#T' after", t
);
9203 cp_error_at ("explicit specialization here", t
);
9206 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
9210 No program shall explicitly instantiate any template more
9213 If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation
9214 was `extern'. If EXTERN_P then the second is. If -frepo, chances
9215 are we already got marked as an explicit instantion because of the
9216 repo file. All these cases are OK. */
9217 if (!CLASSTYPE_INTERFACE_ONLY (t
) && !extern_p
&& !flag_use_repository
)
9218 cp_pedwarn ("duplicate explicit instantiation of `%#T'", t
);
9220 /* If we've already instantiated the template, just return now. */
9221 if (!CLASSTYPE_INTERFACE_ONLY (t
))
9225 mark_class_instantiated (t
, extern_p
);
9226 repo_template_instantiated (t
, extern_p
);
9234 /* In contrast to implicit instantiation, where only the
9235 declarations, and not the definitions, of members are
9236 instantiated, we have here:
9240 The explicit instantiation of a class template specialization
9241 implies the instantiation of all of its members not
9242 previously explicitly specialized in the translation unit
9243 containing the explicit instantiation.
9245 Of course, we can't instantiate member template classes, since
9246 we don't have any arguments for them. Note that the standard
9247 is unclear on whether the instatiation of the members are
9248 *explicit* instantiations or not. We choose to be generous,
9249 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
9250 the explicit instantiation of a class where some of the members
9251 have no definition in the current translation unit. */
9254 for (tmp
= TYPE_METHODS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
9255 if (TREE_CODE (tmp
) == FUNCTION_DECL
9256 && DECL_TEMPLATE_INSTANTIATION (tmp
))
9258 mark_decl_instantiated (tmp
, extern_p
);
9259 repo_template_instantiated (tmp
, extern_p
);
9261 instantiate_decl (tmp
);
9264 for (tmp
= TYPE_FIELDS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
9265 if (TREE_CODE (tmp
) == VAR_DECL
&& DECL_TEMPLATE_INSTANTIATION (tmp
))
9267 mark_decl_instantiated (tmp
, extern_p
);
9268 repo_template_instantiated (tmp
, extern_p
);
9270 instantiate_decl (tmp
);
9273 for (tmp
= CLASSTYPE_TAGS (t
); tmp
; tmp
= TREE_CHAIN (tmp
))
9274 if (IS_AGGR_TYPE (TREE_VALUE (tmp
))
9275 && !uses_template_parms (CLASSTYPE_TI_ARGS (TREE_VALUE (tmp
))))
9276 do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp
)), storage
);
9280 /* Given a function DECL, which is a specialization of TMPL, modify
9281 DECL to be a re-instantiation of TMPL with the same template
9282 arguments. TMPL should be the template into which tsubst'ing
9283 should occur for DECL, not the most general template.
9285 One reason for doing this is a scenario like this:
9288 void f(const T&, int i);
9290 void g() { f(3, 7); }
9293 void f(const T& t, const int i) { }
9295 Note that when the template is first instantiated, with
9296 instantiate_template, the resulting DECL will have no name for the
9297 first parameter, and the wrong type for the second. So, when we go
9298 to instantiate the DECL, we regenerate it. */
9301 regenerate_decl_from_template (decl
, tmpl
)
9311 args
= DECL_TI_ARGS (decl
);
9312 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
9314 /* Unregister the specialization so that when we tsubst we will not
9315 just return DECL. We don't have to unregister DECL from TMPL
9316 because if would only be registered there if it were a partial
9317 instantiation of a specialization, which it isn't: it's a full
9319 gen_tmpl
= most_general_template (tmpl
);
9320 unregistered
= unregister_specialization (decl
, gen_tmpl
);
9322 /* If the DECL was not unregistered then something peculiar is
9323 happening: we created a specialization but did not call
9324 register_specialization for it. */
9325 my_friendly_assert (unregistered
, 0);
9327 if (TREE_CODE (decl
) == VAR_DECL
)
9328 /* Make sure that we can see identifiers, and compute access
9329 correctly, for the class members used in the declaration of
9330 this static variable. */
9331 pushclass (DECL_CONTEXT (decl
), 2);
9333 /* Do the substitution to get the new declaration. */
9334 new_decl
= tsubst (code_pattern
, args
, /*complain=*/1, NULL_TREE
);
9336 if (TREE_CODE (decl
) == VAR_DECL
)
9338 /* Set up DECL_INITIAL, since tsubst doesn't. */
9339 DECL_INITIAL (new_decl
) =
9340 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
9341 /*complain=*/1, DECL_TI_TEMPLATE (decl
));
9342 /* Pop the class context we pushed above. */
9345 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
9347 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
9349 DECL_INITIAL (new_decl
) = error_mark_node
;
9350 /* And don't complain about a duplicate definition. */
9351 DECL_INITIAL (decl
) = NULL_TREE
;
9354 /* The immediate parent of the new template is still whatever it was
9355 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
9356 general template. We also reset the DECL_ASSEMBLER_NAME since
9357 tsubst always calculates the name as if the function in question
9358 were really a template instance, and sometimes, with friend
9359 functions, this is not so. See tsubst_friend_function for
9361 DECL_TI_TEMPLATE (new_decl
) = DECL_TI_TEMPLATE (decl
);
9362 DECL_ASSEMBLER_NAME (new_decl
) = DECL_ASSEMBLER_NAME (decl
);
9363 DECL_RTL (new_decl
) = DECL_RTL (decl
);
9365 /* Call duplicate decls to merge the old and new declarations. */
9366 duplicate_decls (new_decl
, decl
);
9368 /* Now, re-register the specialization. */
9369 register_specialization (decl
, gen_tmpl
, args
);
9372 /* Produce the definition of D, a _DECL generated from a template. */
9375 instantiate_decl (d
)
9378 tree tmpl
= DECL_TI_TEMPLATE (d
);
9379 tree args
= DECL_TI_ARGS (d
);
9384 int nested
= in_function_p ();
9385 int pattern_defined
;
9387 char *file
= input_filename
;
9389 /* This function should only be used to instantiate templates for
9390 functions and static member variables. */
9391 my_friendly_assert (TREE_CODE (d
) == FUNCTION_DECL
9392 || TREE_CODE (d
) == VAR_DECL
, 0);
9394 if (DECL_TEMPLATE_INSTANTIATED (d
))
9395 /* D has already been instantiated. It might seem reasonable to
9396 check whether or not D is an explict instantiation, and, if so,
9397 stop here. But when an explicit instantiation is deferred
9398 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
9399 is set, even though we still need to do the instantiation. */
9402 /* If we already have a specialization of this declaration, then
9403 there's no reason to instantiate it. Note that
9404 retrieve_specialization gives us both instantiations and
9405 specializations, so we must explicitly check
9406 DECL_TEMPLATE_SPECIALIZATION. */
9407 gen_tmpl
= most_general_template (tmpl
);
9408 spec
= retrieve_specialization (gen_tmpl
, args
);
9409 if (spec
!= NULL_TREE
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
9412 /* This needs to happen before any tsubsting. */
9413 if (! push_tinst_level (d
))
9416 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
9417 for the instantiation. This is not always the most general
9418 template. Consider, for example:
9421 struct S { template <class U> void f();
9422 template <> void f<int>(); };
9424 and an instantiation of S<double>::f<int>. We want TD to be the
9425 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
9428 /* An instantiation cannot have a definition, so we need a
9429 more general template. */
9430 DECL_TEMPLATE_INSTANTIATION (td
)
9431 /* We must also deal with friend templates. Given:
9433 template <class T> struct S {
9434 template <class U> friend void f() {};
9437 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
9438 so far as the language is concerned, but that's still
9439 where we get the pattern for the instantiation from. On
9440 ther hand, if the definition comes outside the class, say:
9442 template <class T> struct S {
9443 template <class U> friend void f();
9445 template <class U> friend void f() {}
9447 we don't need to look any further. That's what the check for
9448 DECL_INITIAL is for. */
9449 || (TREE_CODE (d
) == FUNCTION_DECL
9450 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (td
)
9451 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (td
)));
9454 /* The present template, TD, should not be a definition. If it
9455 were a definition, we should be using it! Note that we
9456 cannot restructure the loop to just keep going until we find
9457 a template with a definition, since that might go too far if
9458 a specialization was declared, but not defined. */
9459 my_friendly_assert (!(TREE_CODE (d
) == VAR_DECL
9460 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (td
))),
9463 /* Fetch the more general template. */
9464 td
= DECL_TI_TEMPLATE (td
);
9467 code_pattern
= DECL_TEMPLATE_RESULT (td
);
9469 if (TREE_CODE (d
) == FUNCTION_DECL
)
9470 pattern_defined
= (DECL_SAVED_TREE (code_pattern
) != NULL_TREE
);
9472 pattern_defined
= ! DECL_IN_AGGR_P (code_pattern
);
9474 push_to_top_level ();
9475 lineno
= DECL_SOURCE_LINE (d
);
9476 input_filename
= DECL_SOURCE_FILE (d
);
9478 if (pattern_defined
)
9480 repo_template_used (d
);
9482 if (flag_external_templates
&& ! DECL_INTERFACE_KNOWN (d
))
9484 if (flag_alt_external_templates
)
9486 if (interface_unknown
)
9487 warn_if_unknown_interface (d
);
9489 else if (DECL_INTERFACE_KNOWN (code_pattern
))
9491 DECL_INTERFACE_KNOWN (d
) = 1;
9492 DECL_NOT_REALLY_EXTERN (d
) = ! DECL_EXTERNAL (code_pattern
);
9495 warn_if_unknown_interface (code_pattern
);
9499 import_export_decl (d
);
9502 /* Reject all external templates except inline functions. */
9503 if (DECL_INTERFACE_KNOWN (d
)
9504 && ! DECL_NOT_REALLY_EXTERN (d
)
9505 && ! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
)))
9508 if (TREE_CODE (d
) == VAR_DECL
9509 && TREE_READONLY (d
)
9510 && DECL_INITIAL (d
) == NULL_TREE
9511 && DECL_INITIAL (code_pattern
) != NULL_TREE
)
9512 /* We need to set up DECL_INITIAL regardless of pattern_defined if
9513 the variable is a static const initialized in the class body. */;
9514 else if (! pattern_defined
9515 || (! (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_INLINE (d
) && nested
)
9518 /* Defer all templates except inline functions used in another
9519 function. We restore the source position here because it's used
9520 by add_pending_template. */
9522 input_filename
= file
;
9524 if (at_eof
&& !pattern_defined
9525 && DECL_EXPLICIT_INSTANTIATION (d
))
9528 The definition of a non-exported function template, a
9529 non-exported member function template, or a non-exported
9530 member function or static data member of a class template
9531 shall be present in every translation unit in which it is
9532 explicitly instantiated. */
9533 cp_error ("explicit instantiation of `%D' but no definition available",
9536 add_pending_template (d
);
9540 /* We're now committed to instantiating this template. Mark it as
9541 instantiated so that recursive calls to instantiate_decl do not
9542 try to instantiate it again. */
9543 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
9545 /* Regenerate the declaration in case the template has been modified
9546 by a subsequent redeclaration. */
9547 regenerate_decl_from_template (d
, td
);
9549 /* We already set the file and line above. Reset them now in case
9550 they changed as a result of calling regenerate_decl_from_template. */
9551 lineno
= DECL_SOURCE_LINE (d
);
9552 input_filename
= DECL_SOURCE_FILE (d
);
9554 if (TREE_CODE (d
) == VAR_DECL
)
9556 DECL_IN_AGGR_P (d
) = 0;
9557 if (DECL_INTERFACE_KNOWN (d
))
9558 DECL_EXTERNAL (d
) = ! DECL_NOT_REALLY_EXTERN (d
);
9561 DECL_EXTERNAL (d
) = 1;
9562 DECL_NOT_REALLY_EXTERN (d
) = 1;
9564 cp_finish_decl (d
, DECL_INITIAL (d
), NULL_TREE
, 0);
9566 else if (TREE_CODE (d
) == FUNCTION_DECL
)
9568 /* Set up context. */
9569 start_function (NULL_TREE
, d
, NULL_TREE
, SF_PRE_PARSED
);
9570 store_parm_decls ();
9572 /* We already set up __FUNCTION__, etc., so we don't want to do
9574 current_function_name_declared
= 1;
9576 /* Substitute into the body of the function. */
9577 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
9578 /*complain=*/1, tmpl
);
9580 /* Finish the function. */
9581 expand_body (finish_function (lineno
, 0));
9586 input_filename
= file
;
9588 pop_from_top_level ();
9594 /* Run through the list of templates that we wish we could
9595 instantiate, and instantiate any we can. */
9598 instantiate_pending_templates ()
9601 int instantiated_something
= 0;
9608 t
= &pending_templates
;
9611 tree srcloc
= TREE_PURPOSE (*t
);
9612 tree instantiation
= TREE_VALUE (*t
);
9614 input_filename
= SRCLOC_FILE (srcloc
);
9615 lineno
= SRCLOC_LINE (srcloc
);
9617 if (TREE_CODE_CLASS (TREE_CODE (instantiation
)) == 't')
9621 if (!TYPE_SIZE (instantiation
))
9623 instantiate_class_template (instantiation
);
9624 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
9625 for (fn
= TYPE_METHODS (instantiation
);
9627 fn
= TREE_CHAIN (fn
))
9628 if (! DECL_ARTIFICIAL (fn
))
9629 instantiate_decl (fn
);
9630 if (TYPE_SIZE (instantiation
))
9632 instantiated_something
= 1;
9637 if (TYPE_SIZE (instantiation
))
9638 /* If INSTANTIATION has been instantiated, then we don't
9639 need to consider it again in the future. */
9640 *t
= TREE_CHAIN (*t
);
9642 t
= &TREE_CHAIN (*t
);
9646 if (DECL_TEMPLATE_INSTANTIATION (instantiation
)
9647 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
9649 instantiation
= instantiate_decl (instantiation
);
9650 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
9652 instantiated_something
= 1;
9657 if (!DECL_TEMPLATE_INSTANTIATION (instantiation
)
9658 || DECL_TEMPLATE_INSTANTIATED (instantiation
))
9659 /* If INSTANTIATION has been instantiated, then we don't
9660 need to consider it again in the future. */
9661 *t
= TREE_CHAIN (*t
);
9663 t
= &TREE_CHAIN (*t
);
9668 /* Go through the things that are template instantiations if we are
9669 using guiding declarations. */
9670 t
= &maybe_templates
;
9677 fn
= TREE_VALUE (*t
);
9679 if (DECL_INITIAL (fn
))
9680 /* If the FN is already defined, then it was either already
9681 instantiated or, even though guiding declarations were
9682 allowed, a non-template definition was provided. */
9686 template = TREE_PURPOSE (*t
);
9687 args
= get_bindings (template, fn
, NULL_TREE
);
9688 fn
= instantiate_template (template, args
);
9689 instantiate_decl (fn
);
9693 /* Remove this entry from the chain. */
9694 *t
= TREE_CHAIN (*t
);
9696 maybe_template_tail
= t
;
9700 return instantiated_something
;
9703 /* Substitute ARGVEC into T, which is a TREE_LIST. In particular, it
9704 is an initializer list: the TREE_PURPOSEs are DECLs, and the
9705 TREE_VALUEs are initializer values. Used by instantiate_decl. */
9708 tsubst_expr_values (t
, argvec
)
9711 tree first
= NULL_TREE
;
9714 for (; t
; t
= TREE_CHAIN (t
))
9716 tree pur
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
9717 /*complain=*/1, NULL_TREE
);
9718 tree val
= tsubst_expr (TREE_VALUE (t
), argvec
, /*complain=*/1,
9720 *p
= build_tree_list (pur
, val
);
9721 p
= &TREE_CHAIN (*p
);
9726 /* D is an undefined function declaration in the presence of templates with
9727 the same name, listed in FNS. If one of them can produce D as an
9728 instantiation, remember this so we can instantiate it at EOF if D has
9729 not been defined by that time. */
9732 add_maybe_template (d
, fns
)
9737 if (DECL_MAYBE_TEMPLATE (d
))
9740 t
= most_specialized (fns
, d
, NULL_TREE
);
9743 if (t
== error_mark_node
)
9745 cp_error ("ambiguous template instantiation for `%D'", d
);
9749 *maybe_template_tail
= tree_cons (t
, d
, NULL_TREE
);
9750 maybe_template_tail
= &TREE_CHAIN (*maybe_template_tail
);
9751 DECL_MAYBE_TEMPLATE (d
) = 1;
9754 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
9757 set_current_access_from_decl (decl
)
9760 if (TREE_PRIVATE (decl
))
9761 current_access_specifier
= access_private_node
;
9762 else if (TREE_PROTECTED (decl
))
9763 current_access_specifier
= access_protected_node
;
9765 current_access_specifier
= access_public_node
;
9768 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
9769 is the instantiation (which should have been created with
9770 start_enum) and ARGS are the template arguments to use. */
9773 tsubst_enum (tag
, newtag
, args
)
9780 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
9784 /* Note that in a template enum, the TREE_VALUE is the
9785 CONST_DECL, not the corresponding INTEGER_CST. */
9786 value
= tsubst_expr (DECL_INITIAL (TREE_VALUE (e
)),
9787 args
, /*complain=*/1,
9790 /* Give this enumeration constant the correct access. */
9791 set_current_access_from_decl (TREE_VALUE (e
));
9793 /* Actually build the enumerator itself. */
9794 build_enumerator (TREE_PURPOSE (e
), value
, newtag
);
9797 finish_enum (newtag
);
9800 /* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that
9801 is either an instantiation or specialization of a template
9805 set_mangled_name_for_template_decl (decl
)
9808 tree saved_namespace
;
9809 tree context
= NULL_TREE
;
9818 my_friendly_assert (TREE_CODE (decl
) == FUNCTION_DECL
, 0);
9819 my_friendly_assert (DECL_TEMPLATE_INFO (decl
) != NULL_TREE
, 0);
9821 /* The names of template functions must be mangled so as to indicate
9822 what template is being specialized with what template arguments.
9823 For example, each of the following three functions must get
9824 different mangled names:
9827 template <> void f<7>(int);
9828 template <> void f<8>(int); */
9830 targs
= DECL_TI_ARGS (decl
);
9831 if (uses_template_parms (targs
))
9832 /* This DECL is for a partial instantiation. There's no need to
9833 mangle the name of such an entity. */
9836 tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
9837 tparms
= DECL_TEMPLATE_PARMS (tmpl
);
9838 parm_depth
= TMPL_PARMS_DEPTH (tparms
);
9840 /* There should be as many levels of arguments as there are levels
9842 my_friendly_assert (parm_depth
== TMPL_ARGS_DEPTH (targs
), 0);
9844 /* We now compute the PARMS and RET_TYPE to give to
9845 build_decl_overload_real. The PARMS and RET_TYPE are the
9846 parameter and return types of the template, after all but the
9847 innermost template arguments have been substituted, not the
9848 parameter and return types of the function DECL. For example,
9851 template <class T> T f(T);
9853 both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'.
9854 A more subtle example is:
9856 template <class T> struct S { template <class U> void f(T, U); }
9858 Here, if DECL is `void S<int>::f(int, double)', PARMS should be
9859 {int, U}. Thus, the args that we want to subsitute into the
9860 return and parameter type for the function are those in TARGS,
9861 with the innermost level omitted. */
9862 fn_type
= TREE_TYPE (tmpl
);
9863 if (DECL_STATIC_FUNCTION_P (decl
))
9864 context
= DECL_CLASS_CONTEXT (decl
);
9866 if (parm_depth
== 1)
9867 /* No substitution is necessary. */
9874 /* Replace the innermost level of the TARGS with NULL_TREEs to
9875 let tsubst know not to subsitute for those parameters. */
9876 partial_args
= make_tree_vec (TREE_VEC_LENGTH (targs
));
9877 for (i
= 1; i
< TMPL_ARGS_DEPTH (targs
); ++i
)
9878 SET_TMPL_ARGS_LEVEL (partial_args
, i
,
9879 TMPL_ARGS_LEVEL (targs
, i
));
9880 SET_TMPL_ARGS_LEVEL (partial_args
,
9881 TMPL_ARGS_DEPTH (targs
),
9882 make_tree_vec (DECL_NTPARMS (tmpl
)));
9884 /* Now, do the (partial) substitution to figure out the
9885 appropriate function type. */
9886 fn_type
= tsubst (fn_type
, partial_args
, /*complain=*/1, NULL_TREE
);
9887 if (DECL_STATIC_FUNCTION_P (decl
))
9888 context
= tsubst (context
, partial_args
, /*complain=*/1, NULL_TREE
);
9890 /* Substitute into the template parameters to obtain the real
9891 innermost set of parameters. This step is important if the
9892 innermost set of template parameters contains value
9893 parameters whose types depend on outer template parameters. */
9894 TREE_VEC_LENGTH (partial_args
)--;
9895 tparms
= tsubst_template_parms (tparms
, partial_args
, /*complain=*/1);
9898 /* Now, get the innermost parameters and arguments, and figure out
9899 the parameter and return types. */
9900 tparms
= INNERMOST_TEMPLATE_PARMS (tparms
);
9901 targs
= innermost_args (targs
);
9902 ret_type
= TREE_TYPE (fn_type
);
9903 parm_types
= TYPE_ARG_TYPES (fn_type
);
9905 /* For a static member function, we generate a fake `this' pointer,
9906 for the purposes of mangling. This indicates of which class the
9907 function is a member. Because of:
9911 There shall not be a static and a nonstatic member function
9912 with the same name and the same parameter types
9914 we don't have to worry that this will result in a clash with a
9915 non-static member function. */
9916 if (DECL_STATIC_FUNCTION_P (decl
))
9917 parm_types
= hash_tree_chain (build_pointer_type (context
), parm_types
);
9919 /* There should be the same number of template parameters as
9920 template arguments. */
9921 my_friendly_assert (TREE_VEC_LENGTH (tparms
) == TREE_VEC_LENGTH (targs
),
9924 /* If the template is in a namespace, we need to put that into the
9925 mangled name. Unfortunately, build_decl_overload_real does not
9926 get the decl to mangle, so it relies on the current
9927 namespace. Therefore, we set that here temporarily. */
9928 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd', 980702);
9929 saved_namespace
= current_namespace
;
9930 current_namespace
= CP_DECL_CONTEXT (decl
);
9932 /* Actually set the DCL_ASSEMBLER_NAME. */
9933 DECL_ASSEMBLER_NAME (decl
)
9934 = build_decl_overload_real (DECL_NAME (decl
), parm_types
, ret_type
,
9936 DECL_FUNCTION_MEMBER_P (decl
)
9937 + DECL_CONSTRUCTOR_P (decl
));
9939 /* Restore the previously active namespace. */
9940 current_namespace
= saved_namespace
;