1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
31 #include "coretypes.h"
37 #include "tree-inline.h"
46 /* The type of functions taking a tree, and some additional data, and
48 typedef int (*tree_fn_t) (tree, void*);
50 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
51 instantiations have been deferred, either because their definitions
52 were not yet available, or because we were putting off doing the work.
53 The TREE_PURPOSE of each entry is either a DECL (for a function or
54 static data member), or a TYPE (for a class) indicating what we are
55 hoping to instantiate. The TREE_VALUE is not used. */
56 static GTY(()) tree pending_templates;
57 static GTY(()) tree last_pending_template;
59 int processing_template_parmlist;
60 static int template_header_count;
62 static GTY(()) tree saved_trees;
63 static GTY(()) varray_type inline_parm_levels;
64 static size_t inline_parm_levels_used;
66 static GTY(()) tree current_tinst_level;
68 static GTY(()) tree saved_access_scope;
70 /* A map from local variable declarations in the body of the template
71 presently being instantiated to the corresponding instantiated
73 static htab_t local_specializations;
75 #define UNIFY_ALLOW_NONE 0
76 #define UNIFY_ALLOW_MORE_CV_QUAL 1
77 #define UNIFY_ALLOW_LESS_CV_QUAL 2
78 #define UNIFY_ALLOW_DERIVED 4
79 #define UNIFY_ALLOW_INTEGER 8
80 #define UNIFY_ALLOW_OUTER_LEVEL 16
81 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
82 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
83 #define UNIFY_ALLOW_MAX_CORRECTION 128
85 #define GTB_VIA_VIRTUAL 1 /* The base class we are examining is
86 virtual, or a base class of a virtual
88 #define GTB_IGNORE_TYPE 2 /* We don't need to try to unify the current
89 type with the desired type. */
91 static void push_access_scope (tree);
92 static void pop_access_scope (tree);
93 static int resolve_overloaded_unification (tree, tree, tree, tree,
94 unification_kind_t, int);
95 static int try_one_overload (tree, tree, tree, tree, tree,
96 unification_kind_t, int, bool);
97 static int unify (tree, tree, tree, tree, int);
98 static void add_pending_template (tree);
99 static void reopen_tinst_level (tree);
100 static tree classtype_mangled_name (tree);
101 static char* mangle_class_name_for_template (const char *, tree, tree);
102 static tree tsubst_initializer_list (tree, tree);
103 static tree get_class_bindings (tree, tree, tree);
104 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t, int);
105 static void tsubst_enum (tree, tree, tree);
106 static tree add_to_template_args (tree, tree);
107 static tree add_outermost_template_args (tree, tree);
108 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
109 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
110 static int type_unification_real (tree, tree, tree, tree,
111 int, unification_kind_t, int, int);
112 static void note_template_header (int);
113 static tree convert_nontype_argument (tree, tree);
114 static tree convert_template_argument (tree, tree, tree,
115 tsubst_flags_t, int, tree);
116 static tree get_bindings_overload (tree, tree, tree);
117 static int for_each_template_parm (tree, tree_fn_t, void*, htab_t);
118 static tree build_template_parm_index (int, int, int, tree, tree);
119 static int inline_needs_template_parms (tree);
120 static void push_inline_template_parms_recursive (tree, int);
121 static tree retrieve_specialization (tree, tree);
122 static tree retrieve_local_specialization (tree);
123 static tree register_specialization (tree, tree, tree);
124 static void register_local_specialization (tree, tree);
125 static tree reduce_template_parm_level (tree, tree, int);
126 static tree build_template_decl (tree, tree);
127 static int mark_template_parm (tree, void *);
128 static int template_parm_this_level_p (tree, void *);
129 static tree tsubst_friend_function (tree, tree);
130 static tree tsubst_friend_class (tree, tree);
131 static int can_complete_type_without_circularity (tree);
132 static tree get_bindings (tree, tree, tree);
133 static tree get_bindings_real (tree, tree, tree, int, int, int);
134 static int template_decl_level (tree);
135 static int check_cv_quals_for_unify (int, tree, tree);
136 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
137 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
138 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
139 static void regenerate_decl_from_template (tree, tree);
140 static tree most_specialized (tree, tree, tree);
141 static tree most_specialized_class (tree, tree);
142 static int template_class_depth_real (tree, int);
143 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
144 static tree tsubst_decl (tree, tree, tree, tsubst_flags_t);
145 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
146 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
147 static void check_specialization_scope (void);
148 static tree process_partial_specialization (tree);
149 static void set_current_access_from_decl (tree);
150 static void check_default_tmpl_args (tree, tree, int, int);
151 static tree tsubst_call_declarator_parms (tree, tree, tsubst_flags_t, tree);
152 static tree get_template_base_recursive (tree, tree, tree, tree, tree, int);
153 static tree get_template_base (tree, tree, tree, tree);
154 static int verify_class_unification (tree, tree, tree);
155 static tree try_class_unification (tree, tree, tree, tree);
156 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
158 static tree determine_specialization (tree, tree, tree *, int);
159 static int template_args_equal (tree, tree);
160 static void tsubst_default_arguments (tree);
161 static tree for_each_template_parm_r (tree *, int *, void *);
162 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
163 static void copy_default_args_to_explicit_spec (tree);
164 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
165 static int eq_local_specializations (const void *, const void *);
166 static bool dependent_type_p_r (tree);
167 static tree tsubst (tree, tree, tsubst_flags_t, tree);
168 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree);
169 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
171 /* Make the current scope suitable for access checking when we are
172 processing T. T can be FUNCTION_DECL for instantiated function
173 template, or VAR_DECL for static member variable (need by
174 instantiate_decl). */
177 push_access_scope (tree t)
179 my_friendly_assert (TREE_CODE (t) == FUNCTION_DECL
180 || TREE_CODE (t) == VAR_DECL,
183 if (DECL_FRIEND_CONTEXT (t))
184 push_nested_class (DECL_FRIEND_CONTEXT (t));
185 else if (DECL_CLASS_SCOPE_P (t))
186 push_nested_class (DECL_CONTEXT (t));
188 push_to_top_level ();
190 if (TREE_CODE (t) == FUNCTION_DECL)
192 saved_access_scope = tree_cons
193 (NULL_TREE, current_function_decl, saved_access_scope);
194 current_function_decl = t;
198 /* Restore the scope set up by push_access_scope. T is the node we
202 pop_access_scope (tree t)
204 if (TREE_CODE (t) == FUNCTION_DECL)
206 current_function_decl = TREE_VALUE (saved_access_scope);
207 saved_access_scope = TREE_CHAIN (saved_access_scope);
210 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
213 pop_from_top_level ();
216 /* Do any processing required when DECL (a member template
217 declaration) is finished. Returns the TEMPLATE_DECL corresponding
218 to DECL, unless it is a specialization, in which case the DECL
219 itself is returned. */
222 finish_member_template_decl (tree decl)
224 if (decl == error_mark_node)
225 return error_mark_node;
227 my_friendly_assert (DECL_P (decl), 20020812);
229 if (TREE_CODE (decl) == TYPE_DECL)
233 type = TREE_TYPE (decl);
234 if (IS_AGGR_TYPE (type)
235 && CLASSTYPE_TEMPLATE_INFO (type)
236 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
238 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
239 check_member_template (tmpl);
244 else if (TREE_CODE (decl) == FIELD_DECL)
245 error ("data member `%D' cannot be a member template", decl);
246 else if (DECL_TEMPLATE_INFO (decl))
248 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
250 check_member_template (DECL_TI_TEMPLATE (decl));
251 return DECL_TI_TEMPLATE (decl);
257 error ("invalid member template declaration `%D'", decl);
259 return error_mark_node;
262 /* Returns the template nesting level of the indicated class TYPE.
272 A<T>::B<U> has depth two, while A<T> has depth one.
273 Both A<T>::B<int> and A<int>::B<U> have depth one, if
274 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
277 This function is guaranteed to return 0 if passed NULL_TREE so
278 that, for example, `template_class_depth (current_class_type)' is
282 template_class_depth_real (tree type, int count_specializations)
287 type && TREE_CODE (type) != NAMESPACE_DECL;
288 type = (TREE_CODE (type) == FUNCTION_DECL)
289 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
291 if (TREE_CODE (type) != FUNCTION_DECL)
293 if (CLASSTYPE_TEMPLATE_INFO (type)
294 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
295 && ((count_specializations
296 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
297 || uses_template_parms (CLASSTYPE_TI_ARGS (type))))
302 if (DECL_TEMPLATE_INFO (type)
303 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
304 && ((count_specializations
305 && DECL_TEMPLATE_SPECIALIZATION (type))
306 || uses_template_parms (DECL_TI_ARGS (type))))
314 /* Returns the template nesting level of the indicated class TYPE.
315 Like template_class_depth_real, but instantiations do not count in
319 template_class_depth (tree type)
321 return template_class_depth_real (type, /*count_specializations=*/0);
324 /* Returns 1 if processing DECL as part of do_pending_inlines
325 needs us to push template parms. */
328 inline_needs_template_parms (tree decl)
330 if (! DECL_TEMPLATE_INFO (decl))
333 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
334 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
337 /* Subroutine of maybe_begin_member_template_processing.
338 Push the template parms in PARMS, starting from LEVELS steps into the
339 chain, and ending at the beginning, since template parms are listed
343 push_inline_template_parms_recursive (tree parmlist, int levels)
345 tree parms = TREE_VALUE (parmlist);
349 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
351 ++processing_template_decl;
352 current_template_parms
353 = tree_cons (size_int (processing_template_decl),
354 parms, current_template_parms);
355 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
357 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
359 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
361 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
362 my_friendly_assert (DECL_P (parm), 0);
364 switch (TREE_CODE (parm))
373 /* Make a CONST_DECL as is done in process_template_parm.
374 It is ugly that we recreate this here; the original
375 version built in process_template_parm is no longer
377 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
379 DECL_ARTIFICIAL (decl) = 1;
380 TREE_CONSTANT (decl) = TREE_READONLY (decl) = 1;
381 DECL_INITIAL (decl) = DECL_INITIAL (parm);
382 SET_DECL_TEMPLATE_PARM_P (decl);
393 /* Restore the template parameter context for a member template or
394 a friend template defined in a class definition. */
397 maybe_begin_member_template_processing (tree decl)
402 if (inline_needs_template_parms (decl))
404 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
405 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
407 if (DECL_TEMPLATE_SPECIALIZATION (decl))
410 parms = TREE_CHAIN (parms);
413 push_inline_template_parms_recursive (parms, levels);
416 /* Remember how many levels of template parameters we pushed so that
417 we can pop them later. */
418 if (!inline_parm_levels)
419 VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels");
420 if (inline_parm_levels_used == inline_parm_levels->num_elements)
421 VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used);
422 VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels;
423 ++inline_parm_levels_used;
426 /* Undo the effects of begin_member_template_processing. */
429 maybe_end_member_template_processing (void)
433 if (!inline_parm_levels_used)
436 --inline_parm_levels_used;
438 i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used);
441 --processing_template_decl;
442 current_template_parms = TREE_CHAIN (current_template_parms);
447 /* Returns nonzero iff T is a member template function. We must be
450 template <class T> class C { void f(); }
452 Here, f is a template function, and a member, but not a member
453 template. This function does not concern itself with the origin of
454 T, only its present state. So if we have
456 template <class T> class C { template <class U> void f(U); }
458 then neither C<int>::f<char> nor C<T>::f<double> is considered
459 to be a member template. But, `template <class U> void
460 C<int>::f(U)' is considered a member template. */
463 is_member_template (tree t)
465 if (!DECL_FUNCTION_TEMPLATE_P (t))
466 /* Anything that isn't a function or a template function is
467 certainly not a member template. */
470 /* A local class can't have member templates. */
471 if (decl_function_context (t))
474 return (DECL_FUNCTION_MEMBER_P (DECL_TEMPLATE_RESULT (t))
475 /* If there are more levels of template parameters than
476 there are template classes surrounding the declaration,
477 then we have a member template. */
478 && (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) >
479 template_class_depth (DECL_CONTEXT (t))));
483 /* Returns nonzero iff T is a member template class. See
484 is_member_template for a description of what precisely constitutes
485 a member template. */
488 is_member_template_class (tree t)
490 if (!DECL_CLASS_TEMPLATE_P (t))
491 /* Anything that isn't a class template, is certainly not a member
495 if (!DECL_CLASS_SCOPE_P (t))
496 /* Anything whose context isn't a class type is surely not a
500 /* If there are more levels of template parameters than there are
501 template classes surrounding the declaration, then we have a
503 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (t)) >
504 template_class_depth (DECL_CONTEXT (t)));
508 /* Return a new template argument vector which contains all of ARGS,
509 but has as its innermost set of arguments the EXTRA_ARGS. */
512 add_to_template_args (tree args, tree extra_args)
519 extra_depth = TMPL_ARGS_DEPTH (extra_args);
520 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
522 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
523 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
525 for (j = 1; j <= extra_depth; ++j, ++i)
526 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
531 /* Like add_to_template_args, but only the outermost ARGS are added to
532 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
533 (EXTRA_ARGS) levels are added. This function is used to combine
534 the template arguments from a partial instantiation with the
535 template arguments used to attain the full instantiation from the
536 partial instantiation. */
539 add_outermost_template_args (tree args, tree extra_args)
543 /* If there are more levels of EXTRA_ARGS than there are ARGS,
544 something very fishy is going on. */
545 my_friendly_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args),
548 /* If *all* the new arguments will be the EXTRA_ARGS, just return
550 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
553 /* For the moment, we make ARGS look like it contains fewer levels. */
554 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
556 new_args = add_to_template_args (args, extra_args);
558 /* Now, we restore ARGS to its full dimensions. */
559 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
564 /* Return the N levels of innermost template arguments from the ARGS. */
567 get_innermost_template_args (tree args, int n)
573 my_friendly_assert (n >= 0, 20000603);
575 /* If N is 1, just return the innermost set of template arguments. */
577 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
579 /* If we're not removing anything, just return the arguments we were
581 extra_levels = TMPL_ARGS_DEPTH (args) - n;
582 my_friendly_assert (extra_levels >= 0, 20000603);
583 if (extra_levels == 0)
586 /* Make a new set of arguments, not containing the outer arguments. */
587 new_args = make_tree_vec (n);
588 for (i = 1; i <= n; ++i)
589 SET_TMPL_ARGS_LEVEL (new_args, i,
590 TMPL_ARGS_LEVEL (args, i + extra_levels));
595 /* We've got a template header coming up; push to a new level for storing
599 begin_template_parm_list (void)
601 /* We use a non-tag-transparent scope here, which causes pushtag to
602 put tags in this scope, rather than in the enclosing class or
603 namespace scope. This is the right thing, since we want
604 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
605 global template class, push_template_decl handles putting the
606 TEMPLATE_DECL into top-level scope. For a nested template class,
609 template <class T> struct S1 {
610 template <class T> struct S2 {};
613 pushtag contains special code to call pushdecl_with_scope on the
614 TEMPLATE_DECL for S2. */
615 begin_scope (sk_template_parms, NULL);
616 ++processing_template_decl;
617 ++processing_template_parmlist;
618 note_template_header (0);
621 /* This routine is called when a specialization is declared. If it is
622 invalid to declare a specialization here, an error is reported. */
625 check_specialization_scope (void)
627 tree scope = current_scope ();
631 An explicit specialization shall be declared in the namespace of
632 which the template is a member, or, for member templates, in the
633 namespace of which the enclosing class or enclosing class
634 template is a member. An explicit specialization of a member
635 function, member class or static data member of a class template
636 shall be declared in the namespace of which the class template
638 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
639 error ("explicit specialization in non-namespace scope `%D'",
644 In an explicit specialization declaration for a member of a class
645 template or a member template that appears in namespace scope,
646 the member template and some of its enclosing class templates may
647 remain unspecialized, except that the declaration shall not
648 explicitly specialize a class member template if its enclosing
649 class templates are not explicitly specialized as well. */
650 if (current_template_parms)
651 error ("enclosing class templates are not explicitly specialized");
654 /* We've just seen template <>. */
657 begin_specialization (void)
659 begin_scope (sk_template_spec, NULL);
660 note_template_header (1);
661 check_specialization_scope ();
664 /* Called at then end of processing a declaration preceded by
668 end_specialization (void)
671 reset_specialization ();
674 /* Any template <>'s that we have seen thus far are not referring to a
675 function specialization. */
678 reset_specialization (void)
680 processing_specialization = 0;
681 template_header_count = 0;
684 /* We've just seen a template header. If SPECIALIZATION is nonzero,
685 it was of the form template <>. */
688 note_template_header (int specialization)
690 processing_specialization = specialization;
691 template_header_count++;
694 /* We're beginning an explicit instantiation. */
697 begin_explicit_instantiation (void)
699 my_friendly_assert (!processing_explicit_instantiation, 20020913);
700 processing_explicit_instantiation = true;
705 end_explicit_instantiation (void)
707 my_friendly_assert(processing_explicit_instantiation, 20020913);
708 processing_explicit_instantiation = false;
711 /* A explicit specialization or partial specialization TMPL is being
712 declared. Check that the namespace in which the specialization is
713 occurring is permissible. Returns false iff it is invalid to
714 specialize TMPL in the current namespace. */
717 check_specialization_namespace (tree tmpl)
719 tree tpl_ns = decl_namespace_context (tmpl);
723 An explicit specialization shall be declared in the namespace of
724 which the template is a member, or, for member templates, in the
725 namespace of which the enclosing class or enclosing class
726 template is a member. An explicit specialization of a member
727 function, member class or static data member of a class template
728 shall be declared in the namespace of which the class template is
730 if (is_associated_namespace (current_namespace, tpl_ns))
731 /* Same or super-using namespace. */
735 pedwarn ("specialization of `%D' in different namespace", tmpl);
736 cp_pedwarn_at (" from definition of `%#D'", tmpl);
741 /* The TYPE is being declared. If it is a template type, that means it
742 is a partial specialization. Do appropriate error-checking. */
745 maybe_process_partial_specialization (tree type)
749 if (type == error_mark_node)
752 context = TYPE_CONTEXT (type);
754 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
756 /* This is for ordinary explicit specialization and partial
757 specialization of a template class such as:
759 template <> class C<int>;
763 template <class T> class C<T*>;
765 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
767 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
768 && !COMPLETE_TYPE_P (type))
770 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
771 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
772 if (processing_template_decl)
773 push_template_decl (TYPE_MAIN_DECL (type));
775 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
776 error ("specialization of `%T' after instantiation", type);
778 else if (CLASS_TYPE_P (type)
779 && !CLASSTYPE_USE_TEMPLATE (type)
780 && CLASSTYPE_TEMPLATE_INFO (type)
781 && context && CLASS_TYPE_P (context)
782 && CLASSTYPE_TEMPLATE_INFO (context))
784 /* This is for an explicit specialization of member class
785 template according to [temp.expl.spec/18]:
787 template <> template <class U> class C<int>::D;
789 The context `C<int>' must be an implicit instantiation.
790 Otherwise this is just a member class template declared
793 template <> class C<int> { template <class U> class D; };
794 template <> template <class U> class C<int>::D;
796 In the first case, `C<int>::D' is a specialization of `C<T>::D'
797 while in the second case, `C<int>::D' is a primary template
798 and `C<T>::D' may not exist. */
800 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
801 && !COMPLETE_TYPE_P (type))
805 if (current_namespace
806 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
808 pedwarn ("specializing `%#T' in different namespace", type);
809 cp_pedwarn_at (" from definition of `%#D'",
810 CLASSTYPE_TI_TEMPLATE (type));
813 /* Check for invalid specialization after instantiation:
815 template <> template <> class C<int>::D<int>;
816 template <> template <class U> class C<int>::D; */
818 for (t = DECL_TEMPLATE_INSTANTIATIONS
819 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
820 t; t = TREE_CHAIN (t))
821 if (TREE_VALUE (t) != type
822 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
823 error ("specialization `%T' after instantiation `%T'",
824 type, TREE_VALUE (t));
826 /* Mark TYPE as a specialization. And as a result, we only
827 have one level of template argument for the innermost
829 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
830 CLASSTYPE_TI_ARGS (type)
831 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
834 else if (processing_specialization)
835 error ("explicit specialization of non-template `%T'", type);
838 /* Retrieve the specialization (in the sense of [temp.spec] - a
839 specialization is either an instantiation or an explicit
840 specialization) of TMPL for the given template ARGS. If there is
841 no such specialization, return NULL_TREE. The ARGS are a vector of
842 arguments, or a vector of vectors of arguments, in the case of
843 templates with more than one level of parameters. */
846 retrieve_specialization (tree tmpl, tree args)
850 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
852 /* There should be as many levels of arguments as there are
853 levels of parameters. */
854 my_friendly_assert (TMPL_ARGS_DEPTH (args)
855 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)),
858 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
861 if (comp_template_args (TREE_PURPOSE (s), args))
862 return TREE_VALUE (s);
867 /* Like retrieve_specialization, but for local declarations. */
870 retrieve_local_specialization (tree tmpl)
872 tree spec = htab_find_with_hash (local_specializations, tmpl,
873 htab_hash_pointer (tmpl));
874 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
877 /* Returns nonzero iff DECL is a specialization of TMPL. */
880 is_specialization_of (tree decl, tree tmpl)
884 if (TREE_CODE (decl) == FUNCTION_DECL)
888 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
894 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 0);
896 for (t = TREE_TYPE (decl);
898 t = CLASSTYPE_USE_TEMPLATE (t)
899 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
900 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
907 /* Returns nonzero iff DECL is a specialization of friend declaration
908 FRIEND according to [temp.friend]. */
911 is_specialization_of_friend (tree decl, tree friend)
913 bool need_template = true;
916 my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0);
918 /* For [temp.friend/6] when FRIEND is an ordinary member function
919 of a template class, we want to check if DECL is a specialization
921 if (TREE_CODE (friend) == FUNCTION_DECL
922 && DECL_TEMPLATE_INFO (friend)
923 && !DECL_USE_TEMPLATE (friend))
925 friend = DECL_TI_TEMPLATE (friend);
926 need_template = false;
929 /* There is nothing to do if this is not a template friend. */
930 if (TREE_CODE (friend) != TEMPLATE_DECL)
933 if (is_specialization_of (decl, friend))
937 A member of a class template may be declared to be a friend of a
938 non-template class. In this case, the corresponding member of
939 every specialization of the class template is a friend of the
940 class granting friendship.
942 For example, given a template friend declaration
944 template <class T> friend void A<T>::f();
946 the member function below is considered a friend
948 template <> struct A<int> {
952 For this type of template friend, TEMPLATE_DEPTH below will be
953 nonzero. To determine if DECL is a friend of FRIEND, we first
954 check if the enclosing class is a specialization of another. */
956 template_depth = template_class_depth (DECL_CONTEXT (friend));
958 && DECL_CLASS_SCOPE_P (decl)
959 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
960 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
962 /* Next, we check the members themselves. In order to handle
963 a few tricky cases like
965 template <class T> friend void A<T>::g(T t);
966 template <class T> template <T t> friend void A<T>::h();
968 we need to figure out what ARGS is (corresponding to `T' in above
969 examples) from DECL for later processing. */
971 tree context = DECL_CONTEXT (decl);
972 tree args = NULL_TREE;
973 int current_depth = 0;
974 while (current_depth < template_depth)
976 if (CLASSTYPE_TEMPLATE_INFO (context))
978 if (current_depth == 0)
979 args = TYPE_TI_ARGS (context);
981 args = add_to_template_args (TYPE_TI_ARGS (context), args);
984 context = TYPE_CONTEXT (context);
987 if (TREE_CODE (decl) == FUNCTION_DECL)
992 tree friend_args_type;
995 /* Make sure that both DECL and FRIEND are templates or
997 is_template = DECL_TEMPLATE_INFO (decl)
998 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
999 if (need_template ^ is_template)
1001 else if (is_template)
1003 /* If both are templates, check template parameter list. */
1005 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1007 if (!comp_template_parms
1008 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1012 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1015 decl_type = TREE_TYPE (decl);
1017 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1018 tf_none, NULL_TREE);
1019 if (friend_type == error_mark_node)
1022 /* Check if return types match. */
1023 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1026 /* Check if function parameter types match, ignoring the
1027 `this' parameter. */
1028 friend_args_type = TYPE_ARG_TYPES (friend_type);
1029 decl_args_type = TYPE_ARG_TYPES (decl_type);
1030 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1031 friend_args_type = TREE_CHAIN (friend_args_type);
1032 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1033 decl_args_type = TREE_CHAIN (decl_args_type);
1034 if (compparms (decl_args_type, friend_args_type))
1041 /* Register the specialization SPEC as a specialization of TMPL with
1042 the indicated ARGS. Returns SPEC, or an equivalent prior
1043 declaration, if available. */
1046 register_specialization (tree spec, tree tmpl, tree args)
1050 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
1052 if (TREE_CODE (spec) == FUNCTION_DECL
1053 && uses_template_parms (DECL_TI_ARGS (spec)))
1054 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1055 register it; we want the corresponding TEMPLATE_DECL instead.
1056 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1057 the more obvious `uses_template_parms (spec)' to avoid problems
1058 with default function arguments. In particular, given
1059 something like this:
1061 template <class T> void f(T t1, T t = T())
1063 the default argument expression is not substituted for in an
1064 instantiation unless and until it is actually needed. */
1067 /* There should be as many levels of arguments as there are
1068 levels of parameters. */
1069 my_friendly_assert (TMPL_ARGS_DEPTH (args)
1070 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)),
1073 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1077 tree fn = TREE_VALUE (s);
1079 /* We can sometimes try to re-register a specialization that we've
1080 already got. In particular, regenerate_decl_from_template
1081 calls duplicate_decls which will update the specialization
1082 list. But, we'll still get called again here anyhow. It's
1083 more convenient to simply allow this than to try to prevent it. */
1086 else if (comp_template_args (TREE_PURPOSE (s), args))
1088 if (DECL_TEMPLATE_SPECIALIZATION (spec))
1090 if (DECL_TEMPLATE_INSTANTIATION (fn))
1093 || DECL_EXPLICIT_INSTANTIATION (fn))
1095 error ("specialization of %D after instantiation",
1101 /* This situation should occur only if the first
1102 specialization is an implicit instantiation,
1103 the second is an explicit specialization, and
1104 the implicit instantiation has not yet been
1105 used. That situation can occur if we have
1106 implicitly instantiated a member function and
1107 then specialized it later.
1109 We can also wind up here if a friend
1110 declaration that looked like an instantiation
1111 turns out to be a specialization:
1113 template <class T> void foo(T);
1114 class S { friend void foo<>(int) };
1115 template <> void foo(int);
1117 We transform the existing DECL in place so that
1118 any pointers to it become pointers to the
1119 updated declaration.
1121 If there was a definition for the template, but
1122 not for the specialization, we want this to
1123 look as if there is no definition, and vice
1125 DECL_INITIAL (fn) = NULL_TREE;
1126 duplicate_decls (spec, fn);
1131 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1133 if (!duplicate_decls (spec, fn) && DECL_INITIAL (spec))
1134 /* Dup decl failed, but this is a new
1135 definition. Set the line number so any errors
1136 match this new definition. */
1137 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1145 /* A specialization must be declared in the same namespace as the
1146 template it is specializing. */
1147 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1148 && !check_specialization_namespace (tmpl))
1149 DECL_CONTEXT (spec) = decl_namespace_context (tmpl);
1151 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1152 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1157 /* Unregister the specialization SPEC as a specialization of TMPL.
1158 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1159 if the SPEC was listed as a specialization of TMPL. */
1162 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1166 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1168 s = &TREE_CHAIN (*s))
1169 if (TREE_VALUE (*s) == spec)
1172 *s = TREE_CHAIN (*s);
1174 TREE_VALUE (*s) = new_spec;
1181 /* Compare an entry in the local specializations hash table P1 (which
1182 is really a pointer to a TREE_LIST) with P2 (which is really a
1186 eq_local_specializations (const void *p1, const void *p2)
1188 return TREE_VALUE ((tree) p1) == (tree) p2;
1191 /* Hash P1, an entry in the local specializations table. */
1194 hash_local_specialization (const void* p1)
1196 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1199 /* Like register_specialization, but for local declarations. We are
1200 registering SPEC, an instantiation of TMPL. */
1203 register_local_specialization (tree spec, tree tmpl)
1207 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1208 htab_hash_pointer (tmpl), INSERT);
1209 *slot = build_tree_list (spec, tmpl);
1212 /* Print the list of candidate FNS in an error message. */
1215 print_candidates (tree fns)
1219 const char *str = "candidates are:";
1221 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1225 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1226 cp_error_at ("%s %+#D", str, OVL_CURRENT (f));
1231 /* Returns the template (one of the functions given by TEMPLATE_ID)
1232 which can be specialized to match the indicated DECL with the
1233 explicit template args given in TEMPLATE_ID. The DECL may be
1234 NULL_TREE if none is available. In that case, the functions in
1235 TEMPLATE_ID are non-members.
1237 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1238 specialization of a member template.
1240 The template args (those explicitly specified and those deduced)
1241 are output in a newly created vector *TARGS_OUT.
1243 If it is impossible to determine the result, an error message is
1244 issued. The error_mark_node is returned to indicate failure. */
1247 determine_specialization (tree template_id,
1250 int need_member_template)
1254 tree explicit_targs;
1255 tree candidates = NULL_TREE;
1256 tree templates = NULL_TREE;
1258 *targs_out = NULL_TREE;
1260 if (template_id == error_mark_node)
1261 return error_mark_node;
1263 fns = TREE_OPERAND (template_id, 0);
1264 explicit_targs = TREE_OPERAND (template_id, 1);
1266 if (fns == error_mark_node)
1267 return error_mark_node;
1269 /* Check for baselinks. */
1270 if (BASELINK_P (fns))
1271 fns = BASELINK_FUNCTIONS (fns);
1273 if (!is_overloaded_fn (fns))
1275 error ("`%D' is not a function template", fns);
1276 return error_mark_node;
1279 for (; fns; fns = OVL_NEXT (fns))
1281 tree fn = OVL_CURRENT (fns);
1283 if (TREE_CODE (fn) == TEMPLATE_DECL)
1285 tree decl_arg_types;
1288 /* DECL might be a specialization of FN. */
1290 /* Adjust the type of DECL in case FN is a static member. */
1291 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1292 if (DECL_STATIC_FUNCTION_P (fn)
1293 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1294 decl_arg_types = TREE_CHAIN (decl_arg_types);
1296 /* Check that the number of function parameters matches.
1298 template <class T> void f(int i = 0);
1299 template <> void f<int>();
1300 The specialization f<int> is invalid but is not caught
1301 by get_bindings below. */
1303 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1304 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1307 /* For a non-static member function, we need to make sure that
1308 the const qualification is the same. This can be done by
1309 checking the 'this' in the argument list. */
1310 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1311 && !same_type_p (TREE_VALUE (fn_arg_types),
1312 TREE_VALUE (decl_arg_types)))
1315 /* See whether this function might be a specialization of this
1317 targs = get_bindings (fn, decl, explicit_targs);
1320 /* We cannot deduce template arguments that when used to
1321 specialize TMPL will produce DECL. */
1324 /* Save this template, and the arguments deduced. */
1325 templates = tree_cons (targs, fn, templates);
1327 else if (need_member_template)
1328 /* FN is an ordinary member function, and we need a
1329 specialization of a member template. */
1331 else if (TREE_CODE (fn) != FUNCTION_DECL)
1332 /* We can get IDENTIFIER_NODEs here in certain erroneous
1335 else if (!DECL_FUNCTION_MEMBER_P (fn))
1336 /* This is just an ordinary non-member function. Nothing can
1337 be a specialization of that. */
1339 else if (DECL_ARTIFICIAL (fn))
1340 /* Cannot specialize functions that are created implicitly. */
1344 tree decl_arg_types;
1346 /* This is an ordinary member function. However, since
1347 we're here, we can assume it's enclosing class is a
1348 template class. For example,
1350 template <typename T> struct S { void f(); };
1351 template <> void S<int>::f() {}
1353 Here, S<int>::f is a non-template, but S<int> is a
1354 template class. If FN has the same type as DECL, we
1355 might be in business. */
1357 if (!DECL_TEMPLATE_INFO (fn))
1358 /* Its enclosing class is an explicit specialization
1359 of a template class. This is not a candidate. */
1362 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1363 TREE_TYPE (TREE_TYPE (fn))))
1364 /* The return types differ. */
1367 /* Adjust the type of DECL in case FN is a static member. */
1368 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1369 if (DECL_STATIC_FUNCTION_P (fn)
1370 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1371 decl_arg_types = TREE_CHAIN (decl_arg_types);
1373 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1376 candidates = tree_cons (NULL_TREE, fn, candidates);
1380 if (templates && TREE_CHAIN (templates))
1386 It is possible for a specialization with a given function
1387 signature to be instantiated from more than one function
1388 template. In such cases, explicit specification of the
1389 template arguments must be used to uniquely identify the
1390 function template specialization being specialized.
1392 Note that here, there's no suggestion that we're supposed to
1393 determine which of the candidate templates is most
1394 specialized. However, we, also have:
1398 Partial ordering of overloaded function template
1399 declarations is used in the following contexts to select
1400 the function template to which a function template
1401 specialization refers:
1403 -- when an explicit specialization refers to a function
1406 So, we do use the partial ordering rules, at least for now.
1407 This extension can only serve to make invalid programs valid,
1408 so it's safe. And, there is strong anecdotal evidence that
1409 the committee intended the partial ordering rules to apply;
1410 the EDG front-end has that behavior, and John Spicer claims
1411 that the committee simply forgot to delete the wording in
1412 [temp.expl.spec]. */
1413 tree tmpl = most_specialized (templates, decl, explicit_targs);
1414 if (tmpl && tmpl != error_mark_node)
1416 targs = get_bindings (tmpl, decl, explicit_targs);
1417 templates = tree_cons (targs, tmpl, NULL_TREE);
1421 if (templates == NULL_TREE && candidates == NULL_TREE)
1423 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
1425 return error_mark_node;
1427 else if ((templates && TREE_CHAIN (templates))
1428 || (candidates && TREE_CHAIN (candidates))
1429 || (templates && candidates))
1431 cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1433 chainon (candidates, templates);
1434 print_candidates (candidates);
1435 return error_mark_node;
1438 /* We have one, and exactly one, match. */
1441 /* It was a specialization of an ordinary member function in a
1443 *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates)));
1444 return DECL_TI_TEMPLATE (TREE_VALUE (candidates));
1447 /* It was a specialization of a template. */
1448 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1449 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1451 *targs_out = copy_node (targs);
1452 SET_TMPL_ARGS_LEVEL (*targs_out,
1453 TMPL_ARGS_DEPTH (*targs_out),
1454 TREE_PURPOSE (templates));
1457 *targs_out = TREE_PURPOSE (templates);
1458 return TREE_VALUE (templates);
1461 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1462 but with the default argument values filled in from those in the
1466 copy_default_args_to_explicit_spec_1 (tree spec_types,
1469 tree new_spec_types;
1474 if (spec_types == void_list_node)
1475 return void_list_node;
1477 /* Substitute into the rest of the list. */
1479 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1480 TREE_CHAIN (tmpl_types));
1482 /* Add the default argument for this parameter. */
1483 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1484 TREE_VALUE (spec_types),
1488 /* DECL is an explicit specialization. Replicate default arguments
1489 from the template it specializes. (That way, code like:
1491 template <class T> void f(T = 3);
1492 template <> void f(double);
1495 works, as required.) An alternative approach would be to look up
1496 the correct default arguments at the call-site, but this approach
1497 is consistent with how implicit instantiations are handled. */
1500 copy_default_args_to_explicit_spec (tree decl)
1505 tree new_spec_types;
1509 tree object_type = NULL_TREE;
1510 tree in_charge = NULL_TREE;
1511 tree vtt = NULL_TREE;
1513 /* See if there's anything we need to do. */
1514 tmpl = DECL_TI_TEMPLATE (decl);
1515 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1516 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1517 if (TREE_PURPOSE (t))
1522 old_type = TREE_TYPE (decl);
1523 spec_types = TYPE_ARG_TYPES (old_type);
1525 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1527 /* Remove the this pointer, but remember the object's type for
1529 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1530 spec_types = TREE_CHAIN (spec_types);
1531 tmpl_types = TREE_CHAIN (tmpl_types);
1533 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1535 /* DECL may contain more parameters than TMPL due to the extra
1536 in-charge parameter in constructors and destructors. */
1537 in_charge = spec_types;
1538 spec_types = TREE_CHAIN (spec_types);
1540 if (DECL_HAS_VTT_PARM_P (decl))
1543 spec_types = TREE_CHAIN (spec_types);
1547 /* Compute the merged default arguments. */
1549 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1551 /* Compute the new FUNCTION_TYPE. */
1555 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1560 /* Put the in-charge parameter back. */
1561 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1562 TREE_VALUE (in_charge),
1565 new_type = build_method_type_directly (object_type,
1566 TREE_TYPE (old_type),
1570 new_type = build_function_type (TREE_TYPE (old_type),
1572 new_type = cp_build_type_attribute_variant (new_type,
1573 TYPE_ATTRIBUTES (old_type));
1574 new_type = build_exception_variant (new_type,
1575 TYPE_RAISES_EXCEPTIONS (old_type));
1576 TREE_TYPE (decl) = new_type;
1579 /* Check to see if the function just declared, as indicated in
1580 DECLARATOR, and in DECL, is a specialization of a function
1581 template. We may also discover that the declaration is an explicit
1582 instantiation at this point.
1584 Returns DECL, or an equivalent declaration that should be used
1585 instead if all goes well. Issues an error message if something is
1586 amiss. Returns error_mark_node if the error is not easily
1589 FLAGS is a bitmask consisting of the following flags:
1591 2: The function has a definition.
1592 4: The function is a friend.
1594 The TEMPLATE_COUNT is the number of references to qualifying
1595 template classes that appeared in the name of the function. For
1598 template <class T> struct S { void f(); };
1601 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1602 classes are not counted in the TEMPLATE_COUNT, so that in
1604 template <class T> struct S {};
1605 template <> struct S<int> { void f(); }
1606 template <> void S<int>::f();
1608 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1609 invalid; there should be no template <>.)
1611 If the function is a specialization, it is marked as such via
1612 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1613 is set up correctly, and it is added to the list of specializations
1614 for that template. */
1617 check_explicit_specialization (tree declarator,
1622 int have_def = flags & 2;
1623 int is_friend = flags & 4;
1624 int specialization = 0;
1625 int explicit_instantiation = 0;
1626 int member_specialization = 0;
1627 tree ctype = DECL_CLASS_CONTEXT (decl);
1628 tree dname = DECL_NAME (decl);
1631 tsk = current_tmpl_spec_kind (template_count);
1636 if (processing_specialization)
1639 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1641 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1644 /* This could be something like:
1646 template <class T> void f(T);
1647 class S { friend void f<>(int); } */
1651 /* This case handles bogus declarations like template <>
1652 template <class T> void f<int>(); */
1654 error ("template-id `%D' in declaration of primary template",
1661 case tsk_invalid_member_spec:
1662 /* The error has already been reported in
1663 check_specialization_scope. */
1664 return error_mark_node;
1666 case tsk_invalid_expl_inst:
1667 error ("template parameter list used in explicit instantiation");
1673 error ("definition provided for explicit instantiation");
1675 explicit_instantiation = 1;
1678 case tsk_excessive_parms:
1679 error ("too many template parameter lists in declaration of `%D'",
1681 return error_mark_node;
1685 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1687 member_specialization = 1;
1692 case tsk_insufficient_parms:
1693 if (template_header_count)
1695 error("too few template parameter lists in declaration of `%D'",
1699 else if (ctype != NULL_TREE
1700 && !TYPE_BEING_DEFINED (ctype)
1701 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)
1704 /* For backwards compatibility, we accept:
1706 template <class T> struct S { void f(); };
1707 void S<int>::f() {} // Missing template <>
1709 That used to be valid C++. */
1712 ("explicit specialization not preceded by `template <>'");
1714 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1719 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1721 /* This case handles bogus declarations like template <>
1722 template <class T> void f<int>(); */
1724 if (uses_template_parms (declarator))
1725 error ("partial specialization `%D' of function template",
1728 error ("template-id `%D' in declaration of primary template",
1733 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1734 /* This is a specialization of a member template, without
1735 specialization the containing class. Something like:
1737 template <class T> struct S {
1738 template <class U> void f (U);
1740 template <> template <class U> void S<int>::f(U) {}
1742 That's a specialization -- but of the entire template. */
1750 if (specialization || member_specialization)
1752 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1753 for (; t; t = TREE_CHAIN (t))
1754 if (TREE_PURPOSE (t))
1757 ("default argument specified in explicit specialization");
1760 if (current_lang_name == lang_name_c)
1761 error ("template specialization with C linkage");
1764 if (specialization || member_specialization || explicit_instantiation)
1766 tree tmpl = NULL_TREE;
1767 tree targs = NULL_TREE;
1769 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1770 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1774 my_friendly_assert (TREE_CODE (declarator) == IDENTIFIER_NODE, 0);
1779 /* If there is no class context, the explicit instantiation
1780 must be at namespace scope. */
1781 my_friendly_assert (DECL_NAMESPACE_SCOPE_P (decl), 20030625);
1783 /* Find the namespace binding, using the declaration
1785 fns = namespace_binding (dname, CP_DECL_CONTEXT (decl));
1786 if (!fns || !is_overloaded_fn (fns))
1788 error ("`%D' is not a template function", dname);
1789 fns = error_mark_node;
1793 declarator = lookup_template_function (fns, NULL_TREE);
1796 if (declarator == error_mark_node)
1797 return error_mark_node;
1799 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1801 if (!explicit_instantiation)
1802 /* A specialization in class scope. This is invalid,
1803 but the error will already have been flagged by
1804 check_specialization_scope. */
1805 return error_mark_node;
1808 /* It's not valid to write an explicit instantiation in
1811 class C { template void f(); }
1813 This case is caught by the parser. However, on
1816 template class C { void f(); };
1818 (which is invalid) we can get here. The error will be
1825 else if (ctype != NULL_TREE
1826 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
1829 /* Find the list of functions in ctype that have the same
1830 name as the declared function. */
1831 tree name = TREE_OPERAND (declarator, 0);
1832 tree fns = NULL_TREE;
1835 if (constructor_name_p (name, ctype))
1837 int is_constructor = DECL_CONSTRUCTOR_P (decl);
1839 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
1840 : !TYPE_HAS_DESTRUCTOR (ctype))
1842 /* From [temp.expl.spec]:
1844 If such an explicit specialization for the member
1845 of a class template names an implicitly-declared
1846 special member function (clause _special_), the
1847 program is ill-formed.
1849 Similar language is found in [temp.explicit]. */
1850 error ("specialization of implicitly-declared special member function");
1851 return error_mark_node;
1854 name = is_constructor ? ctor_identifier : dtor_identifier;
1857 if (!DECL_CONV_FN_P (decl))
1859 idx = lookup_fnfields_1 (ctype, name);
1861 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), idx);
1867 /* For a type-conversion operator, we cannot do a
1868 name-based lookup. We might be looking for `operator
1869 int' which will be a specialization of `operator T'.
1870 So, we find *all* the conversion operators, and then
1871 select from them. */
1874 methods = CLASSTYPE_METHOD_VEC (ctype);
1876 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
1877 idx < TREE_VEC_LENGTH (methods); ++idx)
1879 tree ovl = TREE_VEC_ELT (methods, idx);
1881 if (!ovl || !DECL_CONV_FN_P (OVL_CURRENT (ovl)))
1882 /* There are no more conversion functions. */
1885 /* Glue all these conversion functions together
1886 with those we already have. */
1887 for (; ovl; ovl = OVL_NEXT (ovl))
1888 fns = ovl_cons (OVL_CURRENT (ovl), fns);
1892 if (fns == NULL_TREE)
1894 error ("no member function `%D' declared in `%T'",
1896 return error_mark_node;
1899 TREE_OPERAND (declarator, 0) = fns;
1902 /* Figure out what exactly is being specialized at this point.
1903 Note that for an explicit instantiation, even one for a
1904 member function, we cannot tell apriori whether the
1905 instantiation is for a member template, or just a member
1906 function of a template class. Even if a member template is
1907 being instantiated, the member template arguments may be
1908 elided if they can be deduced from the rest of the
1910 tmpl = determine_specialization (declarator, decl,
1912 member_specialization);
1914 if (!tmpl || tmpl == error_mark_node)
1915 /* We couldn't figure out what this declaration was
1917 return error_mark_node;
1920 tree gen_tmpl = most_general_template (tmpl);
1922 if (explicit_instantiation)
1924 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1925 is done by do_decl_instantiation later. */
1927 int arg_depth = TMPL_ARGS_DEPTH (targs);
1928 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
1930 if (arg_depth > parm_depth)
1932 /* If TMPL is not the most general template (for
1933 example, if TMPL is a friend template that is
1934 injected into namespace scope), then there will
1935 be too many levels of TARGS. Remove some of them
1940 new_targs = make_tree_vec (parm_depth);
1941 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
1942 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
1943 = TREE_VEC_ELT (targs, i);
1947 return instantiate_template (tmpl, targs, tf_error);
1950 /* If we thought that the DECL was a member function, but it
1951 turns out to be specializing a static member function,
1952 make DECL a static member function as well. */
1953 if (DECL_STATIC_FUNCTION_P (tmpl)
1954 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1955 revert_static_member_fn (decl);
1957 /* If this is a specialization of a member template of a
1958 template class. In we want to return the TEMPLATE_DECL,
1959 not the specialization of it. */
1960 if (tsk == tsk_template)
1962 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
1963 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
1966 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
1967 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
1968 = DECL_SOURCE_LOCATION (decl);
1969 /* We want to use the argument list specified in the
1970 definition, not in the original declaration. */
1971 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
1972 = DECL_ARGUMENTS (decl);
1977 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1978 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
1980 /* Inherit default function arguments from the template
1981 DECL is specializing. */
1982 copy_default_args_to_explicit_spec (decl);
1984 /* This specialization has the same protection as the
1985 template it specializes. */
1986 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
1987 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
1989 if (is_friend && !have_def)
1990 /* This is not really a declaration of a specialization.
1991 It's just the name of an instantiation. But, it's not
1992 a request for an instantiation, either. */
1993 SET_DECL_IMPLICIT_INSTANTIATION (decl);
1994 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
1995 /* This is indeed a specialization. In case of constructors
1996 and destructors, we need in-charge and not-in-charge
1997 versions in V3 ABI. */
1998 clone_function_decl (decl, /*update_method_vec_p=*/0);
2000 /* Register this specialization so that we can find it
2002 decl = register_specialization (decl, gen_tmpl, targs);
2009 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2010 parameters. These are represented in the same format used for
2011 DECL_TEMPLATE_PARMS. */
2013 int comp_template_parms (tree parms1, tree parms2)
2018 if (parms1 == parms2)
2021 for (p1 = parms1, p2 = parms2;
2022 p1 != NULL_TREE && p2 != NULL_TREE;
2023 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2025 tree t1 = TREE_VALUE (p1);
2026 tree t2 = TREE_VALUE (p2);
2029 my_friendly_assert (TREE_CODE (t1) == TREE_VEC, 0);
2030 my_friendly_assert (TREE_CODE (t2) == TREE_VEC, 0);
2032 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2035 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2037 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2038 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2040 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2043 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2045 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2050 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2051 /* One set of parameters has more parameters lists than the
2058 /* Complain if DECL shadows a template parameter.
2060 [temp.local]: A template-parameter shall not be redeclared within its
2061 scope (including nested scopes). */
2064 check_template_shadow (tree decl)
2068 /* If we're not in a template, we can't possibly shadow a template
2070 if (!current_template_parms)
2073 /* Figure out what we're shadowing. */
2074 if (TREE_CODE (decl) == OVERLOAD)
2075 decl = OVL_CURRENT (decl);
2076 olddecl = IDENTIFIER_VALUE (DECL_NAME (decl));
2078 /* If there's no previous binding for this name, we're not shadowing
2079 anything, let alone a template parameter. */
2083 /* If we're not shadowing a template parameter, we're done. Note
2084 that OLDDECL might be an OVERLOAD (or perhaps even an
2085 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2087 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2090 /* We check for decl != olddecl to avoid bogus errors for using a
2091 name inside a class. We check TPFI to avoid duplicate errors for
2092 inline member templates. */
2094 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2097 cp_error_at ("declaration of `%#D'", decl);
2098 cp_error_at (" shadows template parm `%#D'", olddecl);
2101 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2102 ORIG_LEVEL, DECL, and TYPE. */
2105 build_template_parm_index (int index,
2111 tree t = make_node (TEMPLATE_PARM_INDEX);
2112 TEMPLATE_PARM_IDX (t) = index;
2113 TEMPLATE_PARM_LEVEL (t) = level;
2114 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2115 TEMPLATE_PARM_DECL (t) = decl;
2116 TREE_TYPE (t) = type;
2117 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2118 TREE_READONLY (t) = TREE_READONLY (decl);
2123 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2124 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2125 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2126 new one is created. */
2129 reduce_template_parm_level (tree index, tree type, int levels)
2131 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2132 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2133 != TEMPLATE_PARM_LEVEL (index) - levels))
2135 tree orig_decl = TEMPLATE_PARM_DECL (index);
2138 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2139 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2140 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2141 DECL_ARTIFICIAL (decl) = 1;
2142 SET_DECL_TEMPLATE_PARM_P (decl);
2144 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2145 TEMPLATE_PARM_LEVEL (index) - levels,
2146 TEMPLATE_PARM_ORIG_LEVEL (index),
2148 TEMPLATE_PARM_DESCENDANTS (index) = t;
2150 /* Template template parameters need this. */
2151 DECL_TEMPLATE_PARMS (decl)
2152 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2155 return TEMPLATE_PARM_DESCENDANTS (index);
2158 /* Process information from new template parameter NEXT and append it to the
2159 LIST being built. */
2162 process_template_parm (tree list, tree next)
2170 my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259);
2171 defval = TREE_PURPOSE (parm);
2172 parm = TREE_VALUE (parm);
2173 is_type = TREE_PURPOSE (parm) == class_type_node;
2177 tree p = TREE_VALUE (tree_last (list));
2179 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2180 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2182 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2190 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260);
2191 /* is a const-param */
2192 parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm),
2194 SET_DECL_TEMPLATE_PARM_P (parm);
2198 The top-level cv-qualifiers on the template-parameter are
2199 ignored when determining its type. */
2200 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2202 /* A template parameter is not modifiable. */
2203 TREE_READONLY (parm) = TREE_CONSTANT (parm) = 1;
2204 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2205 TREE_TYPE (parm) = void_type_node;
2206 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2207 TREE_CONSTANT (decl) = TREE_READONLY (decl) = 1;
2208 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2209 = build_template_parm_index (idx, processing_template_decl,
2210 processing_template_decl,
2211 decl, TREE_TYPE (parm));
2216 parm = TREE_VALUE (parm);
2218 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2220 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2221 /* This is for distinguishing between real templates and template
2222 template parameters */
2223 TREE_TYPE (parm) = t;
2224 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2229 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2230 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2231 decl = build_decl (TYPE_DECL, parm, t);
2234 TYPE_NAME (t) = decl;
2235 TYPE_STUB_DECL (t) = decl;
2237 TEMPLATE_TYPE_PARM_INDEX (t)
2238 = build_template_parm_index (idx, processing_template_decl,
2239 processing_template_decl,
2240 decl, TREE_TYPE (parm));
2242 DECL_ARTIFICIAL (decl) = 1;
2243 SET_DECL_TEMPLATE_PARM_P (decl);
2245 parm = build_tree_list (defval, parm);
2246 return chainon (list, parm);
2249 /* The end of a template parameter list has been reached. Process the
2250 tree list into a parameter vector, converting each parameter into a more
2251 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2255 end_template_parm_list (tree parms)
2259 tree saved_parmlist = make_tree_vec (list_length (parms));
2261 current_template_parms
2262 = tree_cons (size_int (processing_template_decl),
2263 saved_parmlist, current_template_parms);
2265 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2267 next = TREE_CHAIN (parm);
2268 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2269 TREE_CHAIN (parm) = NULL_TREE;
2272 --processing_template_parmlist;
2274 return saved_parmlist;
2277 /* end_template_decl is called after a template declaration is seen. */
2280 end_template_decl (void)
2282 reset_specialization ();
2284 if (! processing_template_decl)
2287 /* This matches the pushlevel in begin_template_parm_list. */
2290 --processing_template_decl;
2291 current_template_parms = TREE_CHAIN (current_template_parms);
2294 /* Given a template argument vector containing the template PARMS.
2295 The innermost PARMS are given first. */
2298 current_template_args (void)
2301 tree args = NULL_TREE;
2302 int length = TMPL_PARMS_DEPTH (current_template_parms);
2305 /* If there is only one level of template parameters, we do not
2306 create a TREE_VEC of TREE_VECs. Instead, we return a single
2307 TREE_VEC containing the arguments. */
2309 args = make_tree_vec (length);
2311 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2313 tree a = copy_node (TREE_VALUE (header));
2316 TREE_TYPE (a) = NULL_TREE;
2317 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2319 tree t = TREE_VEC_ELT (a, i);
2321 /* T will be a list if we are called from within a
2322 begin/end_template_parm_list pair, but a vector directly
2323 if within a begin/end_member_template_processing pair. */
2324 if (TREE_CODE (t) == TREE_LIST)
2328 if (TREE_CODE (t) == TYPE_DECL
2329 || TREE_CODE (t) == TEMPLATE_DECL)
2332 t = DECL_INITIAL (t);
2333 TREE_VEC_ELT (a, i) = t;
2338 TREE_VEC_ELT (args, --l) = a;
2346 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2347 template PARMS. Used by push_template_decl below. */
2350 build_template_decl (tree decl, tree parms)
2352 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2353 DECL_TEMPLATE_PARMS (tmpl) = parms;
2354 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2355 if (DECL_LANG_SPECIFIC (decl))
2357 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2358 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2359 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2360 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2361 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2362 if (DECL_OVERLOADED_OPERATOR_P (decl))
2363 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2364 DECL_OVERLOADED_OPERATOR_P (decl));
2370 struct template_parm_data
2372 /* The level of the template parameters we are currently
2376 /* The index of the specialization argument we are currently
2380 /* An array whose size is the number of template parameters. The
2381 elements are nonzero if the parameter has been used in any one
2382 of the arguments processed so far. */
2385 /* An array whose size is the number of template arguments. The
2386 elements are nonzero if the argument makes use of template
2387 parameters of this level. */
2388 int* arg_uses_template_parms;
2391 /* Subroutine of push_template_decl used to see if each template
2392 parameter in a partial specialization is used in the explicit
2393 argument list. If T is of the LEVEL given in DATA (which is
2394 treated as a template_parm_data*), then DATA->PARMS is marked
2398 mark_template_parm (tree t, void* data)
2402 struct template_parm_data* tpd = (struct template_parm_data*) data;
2404 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2406 level = TEMPLATE_PARM_LEVEL (t);
2407 idx = TEMPLATE_PARM_IDX (t);
2411 level = TEMPLATE_TYPE_LEVEL (t);
2412 idx = TEMPLATE_TYPE_IDX (t);
2415 if (level == tpd->level)
2417 tpd->parms[idx] = 1;
2418 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2421 /* Return zero so that for_each_template_parm will continue the
2422 traversal of the tree; we want to mark *every* template parm. */
2426 /* Process the partial specialization DECL. */
2429 process_partial_specialization (tree decl)
2431 tree type = TREE_TYPE (decl);
2432 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2433 tree specargs = CLASSTYPE_TI_ARGS (type);
2434 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2435 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2436 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2437 int nargs = TREE_VEC_LENGTH (inner_args);
2438 int ntparms = TREE_VEC_LENGTH (inner_parms);
2440 int did_error_intro = 0;
2441 struct template_parm_data tpd;
2442 struct template_parm_data tpd2;
2444 /* We check that each of the template parameters given in the
2445 partial specialization is used in the argument list to the
2446 specialization. For example:
2448 template <class T> struct S;
2449 template <class T> struct S<T*>;
2451 The second declaration is OK because `T*' uses the template
2452 parameter T, whereas
2454 template <class T> struct S<int>;
2456 is no good. Even trickier is:
2467 The S2<T> declaration is actually invalid; it is a
2468 full-specialization. Of course,
2471 struct S2<T (*)(U)>;
2473 or some such would have been OK. */
2474 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2475 tpd.parms = alloca (sizeof (int) * ntparms);
2476 memset (tpd.parms, 0, sizeof (int) * ntparms);
2478 tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
2479 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2480 for (i = 0; i < nargs; ++i)
2482 tpd.current_arg = i;
2483 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2484 &mark_template_parm,
2488 for (i = 0; i < ntparms; ++i)
2489 if (tpd.parms[i] == 0)
2491 /* One of the template parms was not used in the
2493 if (!did_error_intro)
2495 error ("template parameters not used in partial specialization:");
2496 did_error_intro = 1;
2500 TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2503 /* [temp.class.spec]
2505 The argument list of the specialization shall not be identical to
2506 the implicit argument list of the primary template. */
2507 if (comp_template_args
2509 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2511 error ("partial specialization `%T' does not specialize any template arguments", type);
2513 /* [temp.class.spec]
2515 A partially specialized non-type argument expression shall not
2516 involve template parameters of the partial specialization except
2517 when the argument expression is a simple identifier.
2519 The type of a template parameter corresponding to a specialized
2520 non-type argument shall not be dependent on a parameter of the
2522 my_friendly_assert (nargs == DECL_NTPARMS (maintmpl), 0);
2524 for (i = 0; i < nargs; ++i)
2526 tree arg = TREE_VEC_ELT (inner_args, i);
2527 if (/* These first two lines are the `non-type' bit. */
2529 && TREE_CODE (arg) != TEMPLATE_DECL
2530 /* This next line is the `argument expression is not just a
2531 simple identifier' condition and also the `specialized
2532 non-type argument' bit. */
2533 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2535 if (tpd.arg_uses_template_parms[i])
2536 error ("template argument `%E' involves template parameter(s)", arg);
2539 /* Look at the corresponding template parameter,
2540 marking which template parameters its type depends
2543 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2548 /* We haven't yet initialized TPD2. Do so now. */
2549 tpd2.arg_uses_template_parms
2550 = alloca (sizeof (int) * nargs);
2551 /* The number of parameters here is the number in the
2552 main template, which, as checked in the assertion
2554 tpd2.parms = alloca (sizeof (int) * nargs);
2556 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2559 /* Mark the template parameters. But this time, we're
2560 looking for the template parameters of the main
2561 template, not in the specialization. */
2562 tpd2.current_arg = i;
2563 tpd2.arg_uses_template_parms[i] = 0;
2564 memset (tpd2.parms, 0, sizeof (int) * nargs);
2565 for_each_template_parm (type,
2566 &mark_template_parm,
2570 if (tpd2.arg_uses_template_parms [i])
2572 /* The type depended on some template parameters.
2573 If they are fully specialized in the
2574 specialization, that's OK. */
2576 for (j = 0; j < nargs; ++j)
2577 if (tpd2.parms[j] != 0
2578 && tpd.arg_uses_template_parms [j])
2580 error ("type `%T' of template argument `%E' depends on template parameter(s)",
2590 if (retrieve_specialization (maintmpl, specargs))
2591 /* We've already got this specialization. */
2594 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2595 = tree_cons (inner_args, inner_parms,
2596 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2597 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2601 /* Check that a template declaration's use of default arguments is not
2602 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2603 nonzero if DECL is the thing declared by a primary template.
2604 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2607 check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2610 int last_level_to_check;
2615 A default template-argument shall not be specified in a
2616 function template declaration or a function template definition, nor
2617 in the template-parameter-list of the definition of a member of a
2620 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2621 /* You can't have a function template declaration in a local
2622 scope, nor you can you define a member of a class template in a
2626 if (current_class_type
2627 && !TYPE_BEING_DEFINED (current_class_type)
2628 && DECL_LANG_SPECIFIC (decl)
2629 /* If this is either a friend defined in the scope of the class
2630 or a member function. */
2631 && (DECL_FUNCTION_MEMBER_P (decl)
2632 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2633 : DECL_FRIEND_CONTEXT (decl)
2634 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2636 /* And, if it was a member function, it really was defined in
2637 the scope of the class. */
2638 && (!DECL_FUNCTION_MEMBER_P (decl)
2639 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2640 /* We already checked these parameters when the template was
2641 declared, so there's no need to do it again now. This function
2642 was defined in class scope, but we're processing it's body now
2643 that the class is complete. */
2648 If a template-parameter has a default template-argument, all
2649 subsequent template-parameters shall have a default
2650 template-argument supplied. */
2651 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2653 tree inner_parms = TREE_VALUE (parm_level);
2654 int ntparms = TREE_VEC_LENGTH (inner_parms);
2655 int seen_def_arg_p = 0;
2658 for (i = 0; i < ntparms; ++i)
2660 tree parm = TREE_VEC_ELT (inner_parms, i);
2661 if (TREE_PURPOSE (parm))
2663 else if (seen_def_arg_p)
2665 error ("no default argument for `%D'", TREE_VALUE (parm));
2666 /* For better subsequent error-recovery, we indicate that
2667 there should have been a default argument. */
2668 TREE_PURPOSE (parm) = error_mark_node;
2673 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2674 /* For an ordinary class template, default template arguments are
2675 allowed at the innermost level, e.g.:
2676 template <class T = int>
2678 but, in a partial specialization, they're not allowed even
2679 there, as we have in [temp.class.spec]:
2681 The template parameter list of a specialization shall not
2682 contain default template argument values.
2684 So, for a partial specialization, or for a function template,
2685 we look at all of them. */
2688 /* But, for a primary class template that is not a partial
2689 specialization we look at all template parameters except the
2691 parms = TREE_CHAIN (parms);
2693 /* Figure out what error message to issue. */
2694 if (TREE_CODE (decl) == FUNCTION_DECL)
2695 msg = "default template arguments may not be used in function templates";
2696 else if (is_partial)
2697 msg = "default template arguments may not be used in partial specializations";
2699 msg = "default argument for template parameter for class enclosing `%D'";
2701 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2702 /* If we're inside a class definition, there's no need to
2703 examine the parameters to the class itself. On the one
2704 hand, they will be checked when the class is defined, and,
2705 on the other, default arguments are valid in things like:
2706 template <class T = double>
2707 struct S { template <class U> void f(U); };
2708 Here the default argument for `S' has no bearing on the
2709 declaration of `f'. */
2710 last_level_to_check = template_class_depth (current_class_type) + 1;
2712 /* Check everything. */
2713 last_level_to_check = 0;
2715 for (parm_level = parms;
2716 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2717 parm_level = TREE_CHAIN (parm_level))
2719 tree inner_parms = TREE_VALUE (parm_level);
2723 ntparms = TREE_VEC_LENGTH (inner_parms);
2724 for (i = 0; i < ntparms; ++i)
2725 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2733 /* Clear out the default argument so that we are not
2735 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2738 /* At this point, if we're still interested in issuing messages,
2739 they must apply to classes surrounding the object declared. */
2741 msg = "default argument for template parameter for class enclosing `%D'";
2745 /* Worker for push_template_decl_real, called via
2746 for_each_template_parm. DATA is really an int, indicating the
2747 level of the parameters we are interested in. If T is a template
2748 parameter of that level, return nonzero. */
2751 template_parm_this_level_p (tree t, void* data)
2753 int this_level = *(int *)data;
2756 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2757 level = TEMPLATE_PARM_LEVEL (t);
2759 level = TEMPLATE_TYPE_LEVEL (t);
2760 return level == this_level;
2763 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2764 parameters given by current_template_args, or reuses a
2765 previously existing one, if appropriate. Returns the DECL, or an
2766 equivalent one, if it is replaced via a call to duplicate_decls.
2768 If IS_FRIEND is nonzero, DECL is a friend declaration. */
2771 push_template_decl_real (tree decl, int is_friend)
2779 int new_template_p = 0;
2781 /* See if this is a partial specialization. */
2782 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
2783 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
2784 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
2786 is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl));
2789 /* For a friend, we want the context of the friend function, not
2790 the type of which it is a friend. */
2791 ctx = DECL_CONTEXT (decl);
2792 else if (CP_DECL_CONTEXT (decl)
2793 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
2794 /* In the case of a virtual function, we want the class in which
2796 ctx = CP_DECL_CONTEXT (decl);
2798 /* Otherwise, if we're currently defining some class, the DECL
2799 is assumed to be a member of the class. */
2800 ctx = current_scope ();
2802 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
2805 if (!DECL_CONTEXT (decl))
2806 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2808 /* See if this is a primary template. */
2809 primary = template_parm_scope_p ();
2813 if (current_lang_name == lang_name_c)
2814 error ("template with C linkage");
2815 else if (TREE_CODE (decl) == TYPE_DECL
2816 && ANON_AGGRNAME_P (DECL_NAME (decl)))
2817 error ("template class without a name");
2818 else if (TREE_CODE (decl) == FUNCTION_DECL)
2820 if (DECL_DESTRUCTOR_P (decl))
2824 A destructor shall not be a member template. */
2825 error ("destructor `%D' declared as member template", decl);
2826 return error_mark_node;
2828 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
2829 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
2830 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
2831 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
2832 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
2833 == void_list_node)))
2835 /* [basic.stc.dynamic.allocation]
2837 An allocation function can be a function
2838 template. ... Template allocation functions shall
2839 have two or more parameters. */
2840 error ("invalid template declaration of `%D'", decl);
2844 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
2845 && CLASS_TYPE_P (TREE_TYPE (decl)))
2849 error ("template declaration of `%#D'", decl);
2850 return error_mark_node;
2854 /* Check to see that the rules regarding the use of default
2855 arguments are not being violated. */
2856 check_default_tmpl_args (decl, current_template_parms,
2857 primary, is_partial);
2860 return process_partial_specialization (decl);
2862 args = current_template_args ();
2865 || TREE_CODE (ctx) == FUNCTION_DECL
2866 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
2867 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
2869 if (DECL_LANG_SPECIFIC (decl)
2870 && DECL_TEMPLATE_INFO (decl)
2871 && DECL_TI_TEMPLATE (decl))
2872 tmpl = DECL_TI_TEMPLATE (decl);
2873 /* If DECL is a TYPE_DECL for a class-template, then there won't
2874 be DECL_LANG_SPECIFIC. The information equivalent to
2875 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2876 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
2877 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2878 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2880 /* Since a template declaration already existed for this
2881 class-type, we must be redeclaring it here. Make sure
2882 that the redeclaration is valid. */
2883 redeclare_class_template (TREE_TYPE (decl),
2884 current_template_parms);
2885 /* We don't need to create a new TEMPLATE_DECL; just use the
2886 one we already had. */
2887 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
2891 tmpl = build_template_decl (decl, current_template_parms);
2894 if (DECL_LANG_SPECIFIC (decl)
2895 && DECL_TEMPLATE_SPECIALIZATION (decl))
2897 /* A specialization of a member template of a template
2899 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2900 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
2901 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
2907 tree a, t, current, parms;
2910 if (TREE_CODE (decl) == TYPE_DECL)
2912 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
2913 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2914 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2915 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2916 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
2919 error ("`%D' does not declare a template type", decl);
2923 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
2925 error ("template definition of non-template `%#D'", decl);
2929 tmpl = DECL_TI_TEMPLATE (decl);
2931 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
2932 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
2933 && DECL_TEMPLATE_SPECIALIZATION (decl)
2934 && is_member_template (tmpl))
2938 /* The declaration is a specialization of a member
2939 template, declared outside the class. Therefore, the
2940 innermost template arguments will be NULL, so we
2941 replace them with the arguments determined by the
2942 earlier call to check_explicit_specialization. */
2943 args = DECL_TI_ARGS (decl);
2946 = build_template_decl (decl, current_template_parms);
2947 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
2948 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
2949 DECL_TI_TEMPLATE (decl) = new_tmpl;
2950 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
2951 DECL_TEMPLATE_INFO (new_tmpl)
2952 = tree_cons (tmpl, args, NULL_TREE);
2954 register_specialization (new_tmpl,
2955 most_general_template (tmpl),
2960 /* Make sure the template headers we got make sense. */
2962 parms = DECL_TEMPLATE_PARMS (tmpl);
2963 i = TMPL_PARMS_DEPTH (parms);
2964 if (TMPL_ARGS_DEPTH (args) != i)
2966 error ("expected %d levels of template parms for `%#D', got %d",
2967 i, decl, TMPL_ARGS_DEPTH (args));
2970 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
2972 a = TMPL_ARGS_LEVEL (args, i);
2973 t = INNERMOST_TEMPLATE_PARMS (parms);
2975 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
2977 if (current == decl)
2978 error ("got %d template parameters for `%#D'",
2979 TREE_VEC_LENGTH (a), decl);
2981 error ("got %d template parameters for `%#T'",
2982 TREE_VEC_LENGTH (a), current);
2983 error (" but %d required", TREE_VEC_LENGTH (t));
2984 return error_mark_node;
2987 /* Perhaps we should also check that the parms are used in the
2988 appropriate qualifying scopes in the declarator? */
2990 if (current == decl)
2993 current = TYPE_CONTEXT (current);
2997 DECL_TEMPLATE_RESULT (tmpl) = decl;
2998 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3000 /* Push template declarations for global functions and types. Note
3001 that we do not try to push a global template friend declared in a
3002 template class; such a thing may well depend on the template
3003 parameters of the class. */
3004 if (new_template_p && !ctx
3005 && !(is_friend && template_class_depth (current_class_type) > 0))
3006 tmpl = pushdecl_namespace_level (tmpl);
3010 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3011 if (DECL_CONV_FN_P (tmpl))
3013 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3015 /* It is a conversion operator. See if the type converted to
3016 depends on innermost template operands. */
3018 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3020 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3024 /* The DECL_TI_ARGS of DECL contains full set of arguments refering
3025 back to its most general template. If TMPL is a specialization,
3026 ARGS may only have the innermost set of arguments. Add the missing
3027 argument levels if necessary. */
3028 if (DECL_TEMPLATE_INFO (tmpl))
3029 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3031 info = tree_cons (tmpl, args, NULL_TREE);
3033 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3035 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3036 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
3037 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3038 /* Don't change the name if we've already set it up. */
3039 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
3040 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
3042 else if (DECL_LANG_SPECIFIC (decl))
3043 DECL_TEMPLATE_INFO (decl) = info;
3045 return DECL_TEMPLATE_RESULT (tmpl);
3049 push_template_decl (tree decl)
3051 return push_template_decl_real (decl, 0);
3054 /* Called when a class template TYPE is redeclared with the indicated
3055 template PARMS, e.g.:
3057 template <class T> struct S;
3058 template <class T> struct S {}; */
3061 redeclare_class_template (tree type, tree parms)
3067 if (!TYPE_TEMPLATE_INFO (type))
3069 error ("`%T' is not a template type", type);
3073 tmpl = TYPE_TI_TEMPLATE (type);
3074 if (!PRIMARY_TEMPLATE_P (tmpl))
3075 /* The type is nested in some template class. Nothing to worry
3076 about here; there are no new template parameters for the nested
3080 parms = INNERMOST_TEMPLATE_PARMS (parms);
3081 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3083 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3085 cp_error_at ("previous declaration `%D'", tmpl);
3086 error ("used %d template parameter(s) instead of %d",
3087 TREE_VEC_LENGTH (tmpl_parms),
3088 TREE_VEC_LENGTH (parms));
3092 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3094 tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3095 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3096 tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3097 tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3099 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm))
3101 cp_error_at ("template parameter `%#D'", tmpl_parm);
3102 error ("redeclared here as `%#D'", parm);
3106 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3108 /* We have in [temp.param]:
3110 A template-parameter may not be given default arguments
3111 by two different declarations in the same scope. */
3112 error ("redefinition of default argument for `%#D'", parm);
3113 error ("%J original definition appeared here", tmpl_parm);
3117 if (parm_default != NULL_TREE)
3118 /* Update the previous template parameters (which are the ones
3119 that will really count) with the new default value. */
3120 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3121 else if (tmpl_default != NULL_TREE)
3122 /* Update the new parameters, too; they'll be used as the
3123 parameters for any members. */
3124 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3128 /* Simplify EXPR if it is a non-dependent expression. Returns the
3129 (possibly simplified) expression. */
3132 fold_non_dependent_expr (tree expr)
3134 /* If we're in a template, but EXPR isn't value dependent, simplify
3135 it. We're supposed to treat:
3137 template <typename T> void f(T[1 + 1]);
3138 template <typename T> void f(T[2]);
3140 as two declarations of the same function, for example. */
3141 if (processing_template_decl
3142 && !type_dependent_expression_p (expr)
3143 && !value_dependent_expression_p (expr))
3145 HOST_WIDE_INT saved_processing_template_decl;
3147 saved_processing_template_decl = processing_template_decl;
3148 processing_template_decl = 0;
3149 expr = tsubst_copy_and_build (expr,
3152 /*in_decl=*/NULL_TREE,
3153 /*function_p=*/false);
3154 processing_template_decl = saved_processing_template_decl;
3159 /* Attempt to convert the non-type template parameter EXPR to the
3160 indicated TYPE. If the conversion is successful, return the
3161 converted value. If the conversion is unsuccessful, return
3162 NULL_TREE if we issued an error message, or error_mark_node if we
3163 did not. We issue error messages for out-and-out bad template
3164 parameters, but not simply because the conversion failed, since we
3165 might be just trying to do argument deduction. Both TYPE and EXPR
3166 must be non-dependent. */
3169 convert_nontype_argument (tree type, tree expr)
3173 /* If we are in a template, EXPR may be non-dependent, but still
3174 have a syntactic, rather than semantic, form. For example, EXPR
3175 might be a SCOPE_REF, rather than the VAR_DECL to which the
3176 SCOPE_REF refers. Preserving the qualifying scope is necessary
3177 so that access checking can be performed when the template is
3178 instantiated -- but here we need the resolved form so that we can
3179 convert the argument. */
3180 expr = fold_non_dependent_expr (expr);
3181 expr_type = TREE_TYPE (expr);
3183 /* A template-argument for a non-type, non-template
3184 template-parameter shall be one of:
3186 --an integral constant-expression of integral or enumeration
3189 --the name of a non-type template-parameter; or
3191 --the name of an object or function with external linkage,
3192 including function templates and function template-ids but
3193 excluding non-static class members, expressed as id-expression;
3196 --the address of an object or function with external linkage,
3197 including function templates and function template-ids but
3198 excluding non-static class members, expressed as & id-expression
3199 where the & is optional if the name refers to a function or
3202 --a pointer to member expressed as described in _expr.unary.op_. */
3204 /* An integral constant-expression can include const variables or
3205 . enumerators. Simplify things by folding them to their values,
3206 unless we're about to bind the declaration to a reference
3208 if (INTEGRAL_TYPE_P (expr_type) && TREE_CODE (type) != REFERENCE_TYPE)
3211 tree const_expr = decl_constant_value (expr);
3212 /* In a template, the initializer for a VAR_DECL may not be
3213 marked as TREE_CONSTANT, in which case decl_constant_value
3214 will not return the initializer. Handle that special case
3216 if (expr == const_expr
3217 && DECL_INTEGRAL_CONSTANT_VAR_P (expr)
3218 /* DECL_INITIAL can be NULL if we are processing a
3219 variable initialized to an expression involving itself.
3220 We know it is initialized to a constant -- but not what
3222 && DECL_INITIAL (expr))
3223 const_expr = DECL_INITIAL (expr);
3224 if (expr == const_expr)
3226 expr = fold_non_dependent_expr (const_expr);
3229 if (is_overloaded_fn (expr))
3230 /* OK for now. We'll check that it has external linkage later.
3231 Check this first since if expr_type is the unknown_type_node
3232 we would otherwise complain below. */
3234 else if (TYPE_PTR_TO_MEMBER_P (expr_type))
3236 if (TREE_CODE (expr) != PTRMEM_CST)
3239 else if (TYPE_PTR_P (expr_type)
3240 || TREE_CODE (expr_type) == ARRAY_TYPE
3241 || TREE_CODE (type) == REFERENCE_TYPE
3242 /* If expr is the address of an overloaded function, we
3243 will get the unknown_type_node at this point. */
3244 || expr_type == unknown_type_node)
3250 if (TREE_CODE (expr_type) == ARRAY_TYPE
3251 || (TREE_CODE (type) == REFERENCE_TYPE
3252 && TREE_CODE (e) != ADDR_EXPR))
3256 if (TREE_CODE (e) != ADDR_EXPR)
3259 error ("`%E' is not a valid template argument", expr);
3260 if (TYPE_PTR_P (expr_type))
3262 if (TREE_CODE (TREE_TYPE (expr_type)) == FUNCTION_TYPE)
3263 error ("it must be the address of a function with external linkage");
3265 error ("it must be the address of an object with external linkage");
3267 else if (TYPE_PTR_TO_MEMBER_P (expr_type))
3268 error ("it must be a pointer-to-member of the form `&X::Y'");
3273 referent = TREE_OPERAND (e, 0);
3274 STRIP_NOPS (referent);
3277 if (TREE_CODE (referent) == STRING_CST)
3279 error ("string literal %E is not a valid template argument because it is the address of an object with static linkage",
3284 if (TREE_CODE (referent) == SCOPE_REF)
3285 referent = TREE_OPERAND (referent, 1);
3287 if (is_overloaded_fn (referent))
3288 /* We'll check that it has external linkage later. */
3290 else if (TREE_CODE (referent) != VAR_DECL)
3292 else if (!DECL_EXTERNAL_LINKAGE_P (referent))
3294 error ("address of non-extern `%E' cannot be used as template argument", referent);
3295 return error_mark_node;
3298 else if (INTEGRAL_TYPE_P (expr_type) || TYPE_PTR_TO_MEMBER_P (expr_type))
3300 if (! TREE_CONSTANT (expr))
3303 error ("non-constant `%E' cannot be used as template argument",
3311 error ("type '%T' cannot be used as a value for a non-type "
3312 "template-parameter", expr);
3313 else if (DECL_P (expr))
3314 error ("invalid use of '%D' as a non-type template-argument", expr);
3316 error ("invalid use of '%E' as a non-type template-argument", expr);
3321 switch (TREE_CODE (type))
3326 /* For a non-type template-parameter of integral or enumeration
3327 type, integral promotions (_conv.prom_) and integral
3328 conversions (_conv.integral_) are applied. */
3329 if (!INTEGRAL_TYPE_P (expr_type))
3330 return error_mark_node;
3332 /* It's safe to call digest_init in this case; we know we're
3333 just converting one integral constant expression to another. */
3334 expr = digest_init (type, expr, (tree*) 0);
3336 if (TREE_CODE (expr) != INTEGER_CST)
3337 /* Curiously, some TREE_CONSTANT integral expressions do not
3338 simplify to integer constants. For example, `3 % 0',
3339 remains a TRUNC_MOD_EXPR. */
3348 /* For a non-type template-parameter of type pointer to data
3349 member, qualification conversions (_conv.qual_) are
3351 e = perform_qualification_conversions (type, expr);
3352 if (TREE_CODE (e) == NOP_EXPR)
3353 /* The call to perform_qualification_conversions will
3354 insert a NOP_EXPR over EXPR to do express conversion,
3355 if necessary. But, that will confuse us if we use
3356 this (converted) template parameter to instantiate
3357 another template; then the thing will not look like a
3358 valid template argument. So, just make a new
3359 constant, of the appropriate type. */
3360 e = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr));
3366 tree type_pointed_to = TREE_TYPE (type);
3368 if (TREE_CODE (type_pointed_to) == FUNCTION_TYPE)
3370 /* For a non-type template-parameter of type pointer to
3371 function, only the function-to-pointer conversion
3372 (_conv.func_) is applied. If the template-argument
3373 represents a set of overloaded functions (or a pointer to
3374 such), the matching function is selected from the set
3379 if (TREE_CODE (expr) == ADDR_EXPR)
3380 fns = TREE_OPERAND (expr, 0);
3384 fn = instantiate_type (type_pointed_to, fns, tf_none);
3386 if (fn == error_mark_node)
3387 return error_mark_node;
3389 if (!DECL_EXTERNAL_LINKAGE_P (fn))
3391 if (really_overloaded_fn (fns))
3392 return error_mark_node;
3397 expr = build_unary_op (ADDR_EXPR, fn, 0);
3399 my_friendly_assert (same_type_p (type, TREE_TYPE (expr)),
3405 /* For a non-type template-parameter of type pointer to
3406 object, qualification conversions (_conv.qual_) and the
3407 array-to-pointer conversion (_conv.array_) are applied.
3408 [Note: In particular, neither the null pointer conversion
3409 (_conv.ptr_) nor the derived-to-base conversion
3410 (_conv.ptr_) are applied. Although 0 is a valid
3411 template-argument for a non-type template-parameter of
3412 integral type, it is not a valid template-argument for a
3413 non-type template-parameter of pointer type.]
3415 The call to decay_conversion performs the
3416 array-to-pointer conversion, if appropriate. */
3417 expr = decay_conversion (expr);
3419 if (expr == error_mark_node)
3420 return error_mark_node;
3422 return perform_qualification_conversions (type, expr);
3427 case REFERENCE_TYPE:
3429 tree type_referred_to = TREE_TYPE (type);
3431 /* If this expression already has reference type, get the
3432 underlying object. */
3433 if (TREE_CODE (expr_type) == REFERENCE_TYPE)
3435 if (TREE_CODE (expr) == NOP_EXPR
3436 && TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR)
3438 my_friendly_assert (TREE_CODE (expr) == ADDR_EXPR, 20000604);
3439 expr = TREE_OPERAND (expr, 0);
3440 expr_type = TREE_TYPE (expr);
3443 if (TREE_CODE (type_referred_to) == FUNCTION_TYPE)
3445 /* For a non-type template-parameter of type reference to
3446 function, no conversions apply. If the
3447 template-argument represents a set of overloaded
3448 functions, the matching function is selected from the
3449 set (_over.over_). */
3452 fn = instantiate_type (type_referred_to, expr, tf_none);
3454 if (fn == error_mark_node)
3455 return error_mark_node;
3457 if (!DECL_EXTERNAL_LINKAGE_P (fn))
3459 if (really_overloaded_fn (expr))
3460 /* Don't issue an error here; we might get a different
3461 function if the overloading had worked out
3463 return error_mark_node;
3468 my_friendly_assert (same_type_p (type_referred_to,
3476 /* For a non-type template-parameter of type reference to
3477 object, no conversions apply. The type referred to by the
3478 reference may be more cv-qualified than the (otherwise
3479 identical) type of the template-argument. The
3480 template-parameter is bound directly to the
3481 template-argument, which must be an lvalue. */
3482 if (!same_type_p (TYPE_MAIN_VARIANT (expr_type),
3483 TYPE_MAIN_VARIANT (type_referred_to))
3484 || !at_least_as_qualified_p (type_referred_to,
3486 || !real_lvalue_p (expr))
3487 return error_mark_node;
3490 cxx_mark_addressable (expr);
3491 return build_nop (type, build_address (expr));
3497 my_friendly_assert (TYPE_PTRMEMFUNC_P (type), 20010112);
3499 /* For a non-type template-parameter of type pointer to member
3500 function, no conversions apply. If the template-argument
3501 represents a set of overloaded member functions, the
3502 matching member function is selected from the set
3505 if (!TYPE_PTRMEMFUNC_P (expr_type) &&
3506 expr_type != unknown_type_node)
3507 return error_mark_node;
3509 if (TREE_CODE (expr) == PTRMEM_CST)
3511 /* A ptr-to-member constant. */
3512 if (!same_type_p (type, expr_type))
3513 return error_mark_node;
3518 if (TREE_CODE (expr) != ADDR_EXPR)
3519 return error_mark_node;
3521 expr = instantiate_type (type, expr, tf_none);
3523 if (expr == error_mark_node)
3524 return error_mark_node;
3526 if (!same_type_p (type, TREE_TYPE (expr)))
3527 return error_mark_node;
3534 /* All non-type parameters must have one of these types. */
3539 return error_mark_node;
3542 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3543 template template parameters. Both PARM_PARMS and ARG_PARMS are
3544 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3547 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3548 the case, then extra parameters must have default arguments.
3550 Consider the example:
3551 template <class T, class Allocator = allocator> class vector;
3552 template<template <class U> class TT> class C;
3554 C<vector> is a valid instantiation. PARM_PARMS for the above code
3555 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3556 T and Allocator) and OUTER_ARGS contains the argument that is used to
3557 substitute the TT parameter. */
3560 coerce_template_template_parms (tree parm_parms,
3562 tsubst_flags_t complain,
3566 int nparms, nargs, i;
3569 my_friendly_assert (TREE_CODE (parm_parms) == TREE_VEC, 0);
3570 my_friendly_assert (TREE_CODE (arg_parms) == TREE_VEC, 0);
3572 nparms = TREE_VEC_LENGTH (parm_parms);
3573 nargs = TREE_VEC_LENGTH (arg_parms);
3575 /* The rule here is opposite of coerce_template_parms. */
3578 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE))
3581 for (i = 0; i < nparms; ++i)
3583 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3584 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3586 if (arg == NULL_TREE || arg == error_mark_node
3587 || parm == NULL_TREE || parm == error_mark_node)
3590 if (TREE_CODE (arg) != TREE_CODE (parm))
3593 switch (TREE_CODE (parm))
3599 /* We encounter instantiations of templates like
3600 template <template <template <class> class> class TT>
3603 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3604 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3606 if (!coerce_template_template_parms
3607 (parmparm, argparm, complain, in_decl, outer_args))
3613 /* The tsubst call is used to handle cases such as
3614 template <class T, template <T> class TT> class D;
3615 i.e. the parameter list of TT depends on earlier parameters. */
3617 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3629 /* Convert the indicated template ARG as necessary to match the
3630 indicated template PARM. Returns the converted ARG, or
3631 error_mark_node if the conversion was unsuccessful. Error and
3632 warning messages are issued under control of COMPLAIN. This
3633 conversion is for the Ith parameter in the parameter list. ARGS is
3634 the full set of template arguments deduced so far. */
3637 convert_template_argument (tree parm,
3640 tsubst_flags_t complain,
3646 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3648 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3650 if (TREE_CODE (arg) == TREE_LIST
3651 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3653 /* The template argument was the name of some
3654 member function. That's usually
3655 invalid, but static members are OK. In any
3656 case, grab the underlying fields/functions
3657 and issue an error later if required. */
3658 arg = TREE_VALUE (arg);
3659 TREE_TYPE (arg) = unknown_type_node;
3662 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3663 requires_type = (TREE_CODE (parm) == TYPE_DECL
3664 || requires_tmpl_type);
3666 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3667 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3668 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3669 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3672 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3673 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3674 arg = TYPE_STUB_DECL (arg);
3676 is_type = TYPE_P (arg) || is_tmpl_type;
3678 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3679 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3681 pedwarn ("to refer to a type member of a template parameter, use `typename %E'", arg);
3683 arg = make_typename_type (TREE_OPERAND (arg, 0),
3684 TREE_OPERAND (arg, 1),
3685 complain & tf_error);
3688 if (is_type != requires_type)
3692 if (complain & tf_error)
3694 error ("type/value mismatch at argument %d in template parameter list for `%D'",
3697 error (" expected a constant of type `%T', got `%T'",
3699 (is_tmpl_type ? DECL_NAME (arg) : arg));
3700 else if (requires_tmpl_type)
3701 error (" expected a class template, got `%E'", arg);
3703 error (" expected a type, got `%E'", arg);
3706 return error_mark_node;
3708 if (is_tmpl_type ^ requires_tmpl_type)
3710 if (in_decl && (complain & tf_error))
3712 error ("type/value mismatch at argument %d in template parameter list for `%D'",
3715 error (" expected a type, got `%T'", DECL_NAME (arg));
3717 error (" expected a class template, got `%T'", arg);
3719 return error_mark_node;
3724 if (requires_tmpl_type)
3726 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
3727 /* The number of argument required is not known yet.
3728 Just accept it for now. */
3729 val = TREE_TYPE (arg);
3732 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3733 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3735 if (coerce_template_template_parms (parmparm, argparm,
3741 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3743 if (val != error_mark_node
3744 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
3745 val = TREE_TYPE (val);
3749 if (in_decl && (complain & tf_error))
3751 error ("type/value mismatch at argument %d in template parameter list for `%D'",
3753 error (" expected a template of type `%D', got `%D'", parm, arg);
3756 val = error_mark_node;
3761 val = groktypename (arg);
3765 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
3767 if (invalid_nontype_parm_type_p (t, complain))
3768 return error_mark_node;
3770 if (!uses_template_parms (arg) && !uses_template_parms (t))
3771 /* We used to call digest_init here. However, digest_init
3772 will report errors, which we don't want when complain
3773 is zero. More importantly, digest_init will try too
3774 hard to convert things: for example, `0' should not be
3775 converted to pointer type at this point according to
3776 the standard. Accepting this is not merely an
3777 extension, since deciding whether or not these
3778 conversions can occur is part of determining which
3779 function template to call, or whether a given explicit
3780 argument specification is valid. */
3781 val = convert_nontype_argument (t, arg);
3785 if (val == NULL_TREE)
3786 val = error_mark_node;
3787 else if (val == error_mark_node && (complain & tf_error))
3788 error ("could not convert template argument `%E' to `%T'",
3795 /* Convert all template arguments to their appropriate types, and
3796 return a vector containing the innermost resulting template
3797 arguments. If any error occurs, return error_mark_node. Error and
3798 warning messages are issued under control of COMPLAIN.
3800 If REQUIRE_ALL_ARGUMENTS is nonzero, all arguments must be
3801 provided in ARGLIST, or else trailing parameters must have default
3802 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3803 deduction for any unspecified trailing arguments. */
3806 coerce_template_parms (tree parms,
3809 tsubst_flags_t complain,
3810 int require_all_arguments)
3812 int nparms, nargs, i, lost = 0;
3815 tree new_inner_args;
3817 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3818 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
3819 nparms = TREE_VEC_LENGTH (parms);
3823 && require_all_arguments
3824 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
3826 if (complain & tf_error)
3828 error ("wrong number of template arguments (%d, should be %d)",
3832 cp_error_at ("provided for `%D'", in_decl);
3835 return error_mark_node;
3838 new_inner_args = make_tree_vec (nparms);
3839 new_args = add_outermost_template_args (args, new_inner_args);
3840 for (i = 0; i < nparms; i++)
3845 /* Get the Ith template parameter. */
3846 parm = TREE_VEC_ELT (parms, i);
3848 /* Calculate the Ith argument. */
3850 arg = TREE_VEC_ELT (inner_args, i);
3851 else if (require_all_arguments)
3852 /* There must be a default arg in this case. */
3853 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
3858 my_friendly_assert (arg, 20030727);
3859 if (arg == error_mark_node)
3860 error ("template argument %d is invalid", i + 1);
3862 arg = convert_template_argument (TREE_VALUE (parm),
3863 arg, new_args, complain, i,
3866 if (arg == error_mark_node)
3868 TREE_VEC_ELT (new_inner_args, i) = arg;
3872 return error_mark_node;
3874 return new_inner_args;
3877 /* Returns 1 if template args OT and NT are equivalent. */
3880 template_args_equal (tree ot, tree nt)
3885 if (TREE_CODE (nt) == TREE_VEC)
3886 /* For member templates */
3887 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
3888 else if (TYPE_P (nt))
3889 return TYPE_P (ot) && same_type_p (ot, nt);
3890 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
3893 return cp_tree_equal (ot, nt);
3896 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3897 of template arguments. Returns 0 otherwise. */
3900 comp_template_args (tree oldargs, tree newargs)
3904 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
3907 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
3909 tree nt = TREE_VEC_ELT (newargs, i);
3910 tree ot = TREE_VEC_ELT (oldargs, i);
3912 if (! template_args_equal (ot, nt))
3918 /* Given class template name and parameter list, produce a user-friendly name
3919 for the instantiation. */
3922 mangle_class_name_for_template (const char* name, tree parms, tree arglist)
3924 static struct obstack scratch_obstack;
3925 static char *scratch_firstobj;
3928 if (!scratch_firstobj)
3929 gcc_obstack_init (&scratch_obstack);
3931 obstack_free (&scratch_obstack, scratch_firstobj);
3932 scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
3934 #define ccat(C) obstack_1grow (&scratch_obstack, (C));
3935 #define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
3939 nparms = TREE_VEC_LENGTH (parms);
3940 arglist = INNERMOST_TEMPLATE_ARGS (arglist);
3941 my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268);
3942 for (i = 0; i < nparms; i++)
3944 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3945 tree arg = TREE_VEC_ELT (arglist, i);
3950 if (TREE_CODE (parm) == TYPE_DECL)
3952 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
3955 else if (TREE_CODE (parm) == TEMPLATE_DECL)
3957 if (TREE_CODE (arg) == TEMPLATE_DECL)
3959 /* Already substituted with real template. Just output
3960 the template name here */
3961 tree context = DECL_CONTEXT (arg);
3964 /* The template may be defined in a namespace, or
3965 may be a member template. */
3966 my_friendly_assert (TREE_CODE (context) == NAMESPACE_DECL
3967 || CLASS_TYPE_P (context),
3969 cat(decl_as_string (DECL_CONTEXT (arg), TFF_PLAIN_IDENTIFIER));
3972 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
3975 /* Output the parameter declaration. */
3976 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
3980 my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269);
3982 /* No need to check arglist against parmlist here; we did that
3983 in coerce_template_parms, called from lookup_template_class. */
3984 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
3987 char *bufp = obstack_next_free (&scratch_obstack);
3989 while (bufp[offset - 1] == ' ')
3991 obstack_blank_fast (&scratch_obstack, offset);
3993 /* B<C<char> >, not B<C<char>> */
3994 if (bufp[offset - 1] == '>')
3999 return (char *) obstack_base (&scratch_obstack);
4003 classtype_mangled_name (tree t)
4005 if (CLASSTYPE_TEMPLATE_INFO (t)
4006 /* Specializations have already had their names set up in
4007 lookup_template_class. */
4008 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4010 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4012 /* For non-primary templates, the template parameters are
4013 implicit from their surrounding context. */
4014 if (PRIMARY_TEMPLATE_P (tmpl))
4016 tree name = DECL_NAME (tmpl);
4017 char *mangled_name = mangle_class_name_for_template
4018 (IDENTIFIER_POINTER (name),
4019 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4020 CLASSTYPE_TI_ARGS (t));
4021 tree id = get_identifier (mangled_name);
4022 IDENTIFIER_TEMPLATE (id) = name;
4027 return TYPE_IDENTIFIER (t);
4031 add_pending_template (tree d)
4033 tree ti = (TYPE_P (d)
4034 ? CLASSTYPE_TEMPLATE_INFO (d)
4035 : DECL_TEMPLATE_INFO (d));
4039 if (TI_PENDING_TEMPLATE_FLAG (ti))
4042 /* We are called both from instantiate_decl, where we've already had a
4043 tinst_level pushed, and instantiate_template, where we haven't.
4045 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4048 push_tinst_level (d);
4050 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4051 if (last_pending_template)
4052 TREE_CHAIN (last_pending_template) = pt;
4054 pending_templates = pt;
4056 last_pending_template = pt;
4058 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4065 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4066 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4067 documentation for TEMPLATE_ID_EXPR. */
4070 lookup_template_function (tree fns, tree arglist)
4074 if (fns == error_mark_node || arglist == error_mark_node)
4075 return error_mark_node;
4077 my_friendly_assert (!arglist || TREE_CODE (arglist) == TREE_VEC, 20030726);
4078 my_friendly_assert (fns && (is_overloaded_fn (fns)
4079 || TREE_CODE (fns) == IDENTIFIER_NODE),
4082 if (BASELINK_P (fns))
4084 BASELINK_FUNCTIONS (fns) = build (TEMPLATE_ID_EXPR,
4086 BASELINK_FUNCTIONS (fns),
4091 type = TREE_TYPE (fns);
4092 if (TREE_CODE (fns) == OVERLOAD || !type)
4093 type = unknown_type_node;
4095 return build (TEMPLATE_ID_EXPR, type, fns, arglist);
4098 /* Within the scope of a template class S<T>, the name S gets bound
4099 (in build_self_reference) to a TYPE_DECL for the class, not a
4100 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4101 or one of its enclosing classes, and that type is a template,
4102 return the associated TEMPLATE_DECL. Otherwise, the original
4103 DECL is returned. */
4106 maybe_get_template_decl_from_type_decl (tree decl)
4108 return (decl != NULL_TREE
4109 && TREE_CODE (decl) == TYPE_DECL
4110 && DECL_ARTIFICIAL (decl)
4111 && CLASS_TYPE_P (TREE_TYPE (decl))
4112 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4113 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4116 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4117 parameters, find the desired type.
4119 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4121 IN_DECL, if non-NULL, is the template declaration we are trying to
4124 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4125 the class we are looking up.
4127 Issue error and warning messages under control of COMPLAIN.
4129 If the template class is really a local class in a template
4130 function, then the FUNCTION_CONTEXT is the function in which it is
4131 being instantiated. */
4134 lookup_template_class (tree d1,
4139 tsubst_flags_t complain)
4141 tree template = NULL_TREE, parmlist;
4144 timevar_push (TV_NAME_LOOKUP);
4146 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4148 if (IDENTIFIER_VALUE (d1)
4149 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1)))
4150 template = IDENTIFIER_VALUE (d1);
4154 push_decl_namespace (context);
4155 template = lookup_name (d1, /*prefer_type=*/0);
4156 template = maybe_get_template_decl_from_type_decl (template);
4158 pop_decl_namespace ();
4161 context = DECL_CONTEXT (template);
4163 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4165 tree type = TREE_TYPE (d1);
4167 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4168 an implicit typename for the second A. Deal with it. */
4169 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4170 type = TREE_TYPE (type);
4172 if (CLASSTYPE_TEMPLATE_INFO (type))
4174 template = CLASSTYPE_TI_TEMPLATE (type);
4175 d1 = DECL_NAME (template);
4178 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4179 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4181 template = TYPE_TI_TEMPLATE (d1);
4182 d1 = DECL_NAME (template);
4184 else if (TREE_CODE (d1) == TEMPLATE_DECL
4185 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4188 d1 = DECL_NAME (template);
4189 context = DECL_CONTEXT (template);
4192 /* With something like `template <class T> class X class X { ... };'
4193 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
4194 We don't want to do that, but we have to deal with the situation,
4195 so let's give them some syntax errors to chew on instead of a
4196 crash. Alternatively D1 might not be a template type at all. */
4199 if (complain & tf_error)
4200 error ("`%T' is not a template", d1);
4201 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4204 if (TREE_CODE (template) != TEMPLATE_DECL
4205 /* Make sure it's a user visible template, if it was named by
4207 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4208 && !PRIMARY_TEMPLATE_P (template)))
4210 if (complain & tf_error)
4212 error ("non-template type `%T' used as a template", d1);
4214 cp_error_at ("for template declaration `%D'", in_decl);
4216 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4219 complain &= ~tf_user;
4221 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4223 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4224 template arguments */
4229 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4231 /* Consider an example where a template template parameter declared as
4233 template <class T, class U = std::allocator<T> > class TT
4235 The template parameter level of T and U are one level larger than
4236 of TT. To proper process the default argument of U, say when an
4237 instantiation `TT<int>' is seen, we need to build the full
4238 arguments containing {int} as the innermost level. Outer levels,
4239 available when not appearing as default template argument, can be
4240 obtained from `current_template_args ()'.
4242 Suppose that TT is later substituted with std::vector. The above
4243 instantiation is `TT<int, std::allocator<T> >' with TT at
4244 level 1, and T at level 2, while the template arguments at level 1
4245 becomes {std::vector} and the inner level 2 is {int}. */
4247 if (current_template_parms)
4248 arglist = add_to_template_args (current_template_args (), arglist);
4250 arglist2 = coerce_template_parms (parmlist, arglist, template,
4251 complain, /*require_all_args=*/1);
4252 if (arglist2 == error_mark_node
4253 || (!uses_template_parms (arglist2)
4254 && check_instantiated_args (template, arglist2, complain)))
4255 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4257 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4258 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4262 tree template_type = TREE_TYPE (template);
4265 tree found = NULL_TREE;
4269 int is_partial_instantiation;
4271 gen_tmpl = most_general_template (template);
4272 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4273 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4274 arg_depth = TMPL_ARGS_DEPTH (arglist);
4276 if (arg_depth == 1 && parm_depth > 1)
4278 /* We've been given an incomplete set of template arguments.
4281 template <class T> struct S1 {
4282 template <class U> struct S2 {};
4283 template <class U> struct S2<U*> {};
4286 we will be called with an ARGLIST of `U*', but the
4287 TEMPLATE will be `template <class T> template
4288 <class U> struct S1<T>::S2'. We must fill in the missing
4291 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4293 arg_depth = TMPL_ARGS_DEPTH (arglist);
4296 /* Now we should have enough arguments. */
4297 my_friendly_assert (parm_depth == arg_depth, 0);
4299 /* From here on, we're only interested in the most general
4301 template = gen_tmpl;
4303 /* Calculate the BOUND_ARGS. These will be the args that are
4304 actually tsubst'd into the definition to create the
4308 /* We have multiple levels of arguments to coerce, at once. */
4310 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4312 tree bound_args = make_tree_vec (parm_depth);
4314 for (i = saved_depth,
4315 t = DECL_TEMPLATE_PARMS (template);
4316 i > 0 && t != NULL_TREE;
4317 --i, t = TREE_CHAIN (t))
4319 tree a = coerce_template_parms (TREE_VALUE (t),
4321 complain, /*require_all_args=*/1);
4323 /* Don't process further if one of the levels fails. */
4324 if (a == error_mark_node)
4326 /* Restore the ARGLIST to its full size. */
4327 TREE_VEC_LENGTH (arglist) = saved_depth;
4328 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4331 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4333 /* We temporarily reduce the length of the ARGLIST so
4334 that coerce_template_parms will see only the arguments
4335 corresponding to the template parameters it is
4337 TREE_VEC_LENGTH (arglist)--;
4340 /* Restore the ARGLIST to its full size. */
4341 TREE_VEC_LENGTH (arglist) = saved_depth;
4343 arglist = bound_args;
4347 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4348 INNERMOST_TEMPLATE_ARGS (arglist),
4350 complain, /*require_all_args=*/1);
4352 if (arglist == error_mark_node)
4353 /* We were unable to bind the arguments. */
4354 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4356 /* In the scope of a template class, explicit references to the
4357 template class refer to the type of the template, not any
4358 instantiation of it. For example, in:
4360 template <class T> class C { void f(C<T>); }
4362 the `C<T>' is just the same as `C'. Outside of the
4363 class, however, such a reference is an instantiation. */
4364 if (comp_template_args (TYPE_TI_ARGS (template_type),
4367 found = template_type;
4369 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4373 for (ctx = current_class_type;
4374 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4376 ? TYPE_CONTEXT (ctx)
4377 : DECL_CONTEXT (ctx)))
4378 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4381 /* We're not in the scope of the class, so the
4382 TEMPLATE_TYPE is not the type we want after all. */
4388 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4390 for (tp = &DECL_TEMPLATE_INSTANTIATIONS (template);
4392 tp = &TREE_CHAIN (*tp))
4393 if (comp_template_args (TREE_PURPOSE (*tp), arglist))
4397 /* Use the move-to-front heuristic to speed up future
4399 *tp = TREE_CHAIN (*tp);
4401 = DECL_TEMPLATE_INSTANTIATIONS (template);
4402 DECL_TEMPLATE_INSTANTIATIONS (template) = found;
4404 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_VALUE (found));
4407 /* This type is a "partial instantiation" if any of the template
4408 arguments still involve template parameters. Note that we set
4409 IS_PARTIAL_INSTANTIATION for partial specializations as
4411 is_partial_instantiation = uses_template_parms (arglist);
4413 /* If the deduced arguments are invalid, then the binding
4415 if (!is_partial_instantiation
4416 && check_instantiated_args (template,
4417 INNERMOST_TEMPLATE_ARGS (arglist),
4419 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4421 if (!is_partial_instantiation
4422 && !PRIMARY_TEMPLATE_P (template)
4423 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4425 found = xref_tag_from_type (TREE_TYPE (template),
4426 DECL_NAME (template),
4428 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4431 context = tsubst (DECL_CONTEXT (template), arglist,
4434 context = global_namespace;
4436 /* Create the type. */
4437 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4439 if (!is_partial_instantiation)
4441 set_current_access_from_decl (TYPE_NAME (template_type));
4442 t = start_enum (TYPE_IDENTIFIER (template_type));
4445 /* We don't want to call start_enum for this type, since
4446 the values for the enumeration constants may involve
4447 template parameters. And, no one should be interested
4448 in the enumeration constants for such a type. */
4449 t = make_node (ENUMERAL_TYPE);
4453 t = make_aggr_type (TREE_CODE (template_type));
4454 CLASSTYPE_DECLARED_CLASS (t)
4455 = CLASSTYPE_DECLARED_CLASS (template_type);
4456 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4457 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4459 /* A local class. Make sure the decl gets registered properly. */
4460 if (context == current_function_decl)
4461 pushtag (DECL_NAME (template), t, 0);
4464 /* If we called start_enum or pushtag above, this information
4465 will already be set up. */
4468 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4470 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4471 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4472 TYPE_STUB_DECL (t) = type_decl;
4473 DECL_SOURCE_LOCATION (type_decl)
4474 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4477 type_decl = TYPE_NAME (t);
4479 TREE_PRIVATE (type_decl)
4480 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4481 TREE_PROTECTED (type_decl)
4482 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4484 /* Set up the template information. We have to figure out which
4485 template is the immediate parent if this is a full
4487 if (parm_depth == 1 || is_partial_instantiation
4488 || !PRIMARY_TEMPLATE_P (template))
4489 /* This case is easy; there are no member templates involved. */
4493 /* This is a full instantiation of a member template. Look
4494 for a partial instantiation of which this is an instance. */
4496 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4497 found; found = TREE_CHAIN (found))
4500 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4502 /* We only want partial instantiations, here, not
4503 specializations or full instantiations. */
4504 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4505 || !uses_template_parms (TREE_VALUE (found)))
4508 /* Temporarily reduce by one the number of levels in the
4509 ARGLIST and in FOUND so as to avoid comparing the
4510 last set of arguments. */
4511 TREE_VEC_LENGTH (arglist)--;
4512 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4514 /* See if the arguments match. If they do, then TMPL is
4515 the partial instantiation we want. */
4516 success = comp_template_args (TREE_PURPOSE (found), arglist);
4518 /* Restore the argument vectors to their full size. */
4519 TREE_VEC_LENGTH (arglist)++;
4520 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4531 /* There was no partial instantiation. This happens
4532 where C<T> is a member template of A<T> and it's used
4535 template <typename T> struct B { A<T>::C<int> m; };
4538 Create the partial instantiation.
4540 TREE_VEC_LENGTH (arglist)--;
4541 found = tsubst (template, arglist, complain, NULL_TREE);
4542 TREE_VEC_LENGTH (arglist)++;
4546 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4547 DECL_TEMPLATE_INSTANTIATIONS (template)
4548 = tree_cons (arglist, t,
4549 DECL_TEMPLATE_INSTANTIATIONS (template));
4551 if (TREE_CODE (t) == ENUMERAL_TYPE
4552 && !is_partial_instantiation)
4553 /* Now that the type has been registered on the instantiations
4554 list, we set up the enumerators. Because the enumeration
4555 constants may involve the enumeration type itself, we make
4556 sure to register the type first, and then create the
4557 constants. That way, doing tsubst_expr for the enumeration
4558 constants won't result in recursive calls here; we'll find
4559 the instantiation and exit above. */
4560 tsubst_enum (template_type, t, arglist);
4562 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4564 if (TREE_CODE (t) != ENUMERAL_TYPE)
4565 DECL_NAME (type_decl) = classtype_mangled_name (t);
4566 if (is_partial_instantiation)
4567 /* If the type makes use of template parameters, the
4568 code that generates debugging information will crash. */
4569 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4571 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4573 timevar_pop (TV_NAME_LOOKUP);
4583 /* Called from for_each_template_parm via walk_tree. */
4586 for_each_template_parm_r (tree* tp, int* walk_subtrees, void* d)
4589 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4590 tree_fn_t fn = pfd->fn;
4591 void *data = pfd->data;
4594 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4595 return error_mark_node;
4597 switch (TREE_CODE (t))
4600 if (TYPE_PTRMEMFUNC_P (t))
4606 if (!TYPE_TEMPLATE_INFO (t))
4608 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4609 fn, data, pfd->visited))
4610 return error_mark_node;
4614 /* Since we're not going to walk subtrees, we have to do this
4616 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4618 return error_mark_node;
4622 /* Check the return type. */
4623 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4624 return error_mark_node;
4626 /* Check the parameter types. Since default arguments are not
4627 instantiated until they are needed, the TYPE_ARG_TYPES may
4628 contain expressions that involve template parameters. But,
4629 no-one should be looking at them yet. And, once they're
4630 instantiated, they don't contain template parameters, so
4631 there's no point in looking at them then, either. */
4635 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4636 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
4638 return error_mark_node;
4640 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4641 want walk_tree walking into them itself. */
4647 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
4649 return error_mark_node;
4654 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
4655 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
4657 return error_mark_node;
4662 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
4663 && for_each_template_parm (DECL_INITIAL (t), fn, data,
4665 return error_mark_node;
4666 if (DECL_CONTEXT (t)
4667 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
4669 return error_mark_node;
4672 case BOUND_TEMPLATE_TEMPLATE_PARM:
4673 /* Record template parameters such as `T' inside `TT<T>'. */
4674 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
4675 return error_mark_node;
4678 case TEMPLATE_TEMPLATE_PARM:
4679 case TEMPLATE_TYPE_PARM:
4680 case TEMPLATE_PARM_INDEX:
4681 if (fn && (*fn)(t, data))
4682 return error_mark_node;
4684 return error_mark_node;
4688 /* A template template parameter is encountered. */
4689 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
4690 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4691 return error_mark_node;
4693 /* Already substituted template template parameter */
4699 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
4700 data, pfd->visited))
4701 return error_mark_node;
4705 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
4706 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4707 (TREE_TYPE (t)), fn, data,
4709 return error_mark_node;
4714 /* If there's no type, then this thing must be some expression
4715 involving template parameters. */
4716 if (!fn && !TREE_TYPE (t))
4717 return error_mark_node;
4722 case REINTERPRET_CAST_EXPR:
4723 case CONST_CAST_EXPR:
4724 case STATIC_CAST_EXPR:
4725 case DYNAMIC_CAST_EXPR:
4729 case PSEUDO_DTOR_EXPR:
4731 return error_mark_node;
4735 /* If we do not handle this case specially, we end up walking
4736 the BINFO hierarchy, which is circular, and therefore
4737 confuses walk_tree. */
4739 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
4741 return error_mark_node;
4748 /* We didn't find any template parameters we liked. */
4752 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
4753 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
4754 call FN with the parameter and the DATA.
4755 If FN returns nonzero, the iteration is terminated, and
4756 for_each_template_parm returns 1. Otherwise, the iteration
4757 continues. If FN never returns a nonzero value, the value
4758 returned by for_each_template_parm is 0. If FN is NULL, it is
4759 considered to be the function which always returns 1. */
4762 for_each_template_parm (tree t, tree_fn_t fn, void* data, htab_t visited)
4764 struct pair_fn_data pfd;
4771 /* Walk the tree. (Conceptually, we would like to walk without
4772 duplicates, but for_each_template_parm_r recursively calls
4773 for_each_template_parm, so we would need to reorganize a fair
4774 bit to use walk_tree_without_duplicates, so we keep our own
4777 pfd.visited = visited;
4779 pfd.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer,
4781 result = walk_tree (&t,
4782 for_each_template_parm_r,
4784 pfd.visited) != NULL_TREE;
4788 htab_delete (pfd.visited);
4793 /* Returns true if T depends on any template parameter. */
4796 uses_template_parms (tree t)
4799 int saved_processing_template_decl;
4801 saved_processing_template_decl = processing_template_decl;
4802 if (!saved_processing_template_decl)
4803 processing_template_decl = 1;
4805 dependent_p = dependent_type_p (t);
4806 else if (TREE_CODE (t) == TREE_VEC)
4807 dependent_p = any_dependent_template_arguments_p (t);
4808 else if (TREE_CODE (t) == TREE_LIST)
4809 dependent_p = (uses_template_parms (TREE_VALUE (t))
4810 || uses_template_parms (TREE_CHAIN (t)));
4811 else if (TREE_CODE (t) == TYPE_DECL)
4812 dependent_p = dependent_type_p (TREE_TYPE (t));
4815 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
4816 || TREE_CODE (t) == OVERLOAD
4817 || TREE_CODE (t) == BASELINK
4818 || TREE_CODE (t) == IDENTIFIER_NODE
4819 || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
4820 dependent_p = (type_dependent_expression_p (t)
4821 || value_dependent_expression_p (t));
4822 else if (t == error_mark_node)
4823 dependent_p = false;
4826 processing_template_decl = saved_processing_template_decl;
4831 /* Returns true if T depends on any template parameter with level LEVEL. */
4834 uses_template_parms_level (tree t, int level)
4836 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
4839 static int tinst_depth;
4840 extern int max_tinst_depth;
4841 #ifdef GATHER_STATISTICS
4844 static int tinst_level_tick;
4845 static int last_template_error_tick;
4847 /* We're starting to instantiate D; record the template instantiation context
4848 for diagnostics and to restore it later. */
4851 push_tinst_level (tree d)
4855 if (tinst_depth >= max_tinst_depth)
4857 /* If the instantiation in question still has unbound template parms,
4858 we don't really care if we can't instantiate it, so just return.
4859 This happens with base instantiation for implicit `typename'. */
4860 if (uses_template_parms (d))
4863 last_template_error_tick = tinst_level_tick;
4864 error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",
4865 max_tinst_depth, d);
4867 print_instantiation_context ();
4872 new = build_expr_wfl (d, input_filename, input_line, 0);
4873 TREE_CHAIN (new) = current_tinst_level;
4874 current_tinst_level = new;
4877 #ifdef GATHER_STATISTICS
4878 if (tinst_depth > depth_reached)
4879 depth_reached = tinst_depth;
4886 /* We're done instantiating this template; return to the instantiation
4890 pop_tinst_level (void)
4892 tree old = current_tinst_level;
4894 /* Restore the filename and line number stashed away when we started
4895 this instantiation. */
4896 input_line = TINST_LINE (old);
4897 input_filename = TINST_FILE (old);
4898 extract_interface_info ();
4900 current_tinst_level = TREE_CHAIN (old);
4905 /* We're instantiating a deferred template; restore the template
4906 instantiation context in which the instantiation was requested, which
4907 is one step out from LEVEL. */
4910 reopen_tinst_level (tree level)
4915 for (t = level; t; t = TREE_CHAIN (t))
4918 current_tinst_level = level;
4922 /* Return the outermost template instantiation context, for use with
4923 -falt-external-templates. */
4926 tinst_for_decl (void)
4928 tree p = current_tinst_level;
4931 for (; TREE_CHAIN (p) ; p = TREE_CHAIN (p))
4936 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4937 vector of template arguments, as for tsubst.
4939 Returns an appropriate tsubst'd friend declaration. */
4942 tsubst_friend_function (tree decl, tree args)
4945 location_t saved_loc = input_location;
4947 input_location = DECL_SOURCE_LOCATION (decl);
4949 if (TREE_CODE (decl) == FUNCTION_DECL
4950 && DECL_TEMPLATE_INSTANTIATION (decl)
4951 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
4952 /* This was a friend declared with an explicit template
4953 argument list, e.g.:
4957 to indicate that f was a template instantiation, not a new
4958 function declaration. Now, we have to figure out what
4959 instantiation of what template. */
4961 tree template_id, arglist, fns;
4964 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
4966 /* Friend functions are looked up in the containing namespace scope.
4967 We must enter that scope, to avoid finding member functions of the
4968 current cless with same name. */
4969 push_nested_namespace (ns);
4970 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
4971 tf_error | tf_warning, NULL_TREE);
4972 pop_nested_namespace (ns);
4973 arglist = tsubst (DECL_TI_ARGS (decl), args,
4974 tf_error | tf_warning, NULL_TREE);
4975 template_id = lookup_template_function (fns, arglist);
4977 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
4978 tmpl = determine_specialization (template_id, new_friend,
4980 /*need_member_template=*/0);
4981 new_friend = instantiate_template (tmpl, new_args, tf_error);
4985 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
4987 /* The NEW_FRIEND will look like an instantiation, to the
4988 compiler, but is not an instantiation from the point of view of
4989 the language. For example, we might have had:
4991 template <class T> struct S {
4992 template <class U> friend void f(T, U);
4995 Then, in S<int>, template <class U> void f(int, U) is not an
4996 instantiation of anything. */
4997 if (new_friend == error_mark_node)
4998 return error_mark_node;
5000 DECL_USE_TEMPLATE (new_friend) = 0;
5001 if (TREE_CODE (decl) == TEMPLATE_DECL)
5003 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
5004 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
5005 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5008 /* The mangled name for the NEW_FRIEND is incorrect. The function
5009 is not a template instantiation and should not be mangled like
5010 one. Therefore, we forget the mangling here; we'll recompute it
5011 later if we need it. */
5012 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5014 SET_DECL_RTL (new_friend, NULL_RTX);
5015 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5018 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5021 tree new_friend_template_info;
5022 tree new_friend_result_template_info;
5024 int new_friend_is_defn;
5026 /* We must save some information from NEW_FRIEND before calling
5027 duplicate decls since that function will free NEW_FRIEND if
5029 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5030 new_friend_is_defn =
5031 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5032 (template_for_substitution (new_friend)))
5034 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5036 /* This declaration is a `primary' template. */
5037 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5039 new_friend_result_template_info
5040 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5043 new_friend_result_template_info = NULL_TREE;
5045 /* Inside pushdecl_namespace_level, we will push into the
5046 current namespace. However, the friend function should go
5047 into the namespace of the template. */
5048 ns = decl_namespace_context (new_friend);
5049 push_nested_namespace (ns);
5050 old_decl = pushdecl_namespace_level (new_friend);
5051 pop_nested_namespace (ns);
5053 if (old_decl != new_friend)
5055 /* This new friend declaration matched an existing
5056 declaration. For example, given:
5058 template <class T> void f(T);
5059 template <class U> class C {
5060 template <class T> friend void f(T) {}
5063 the friend declaration actually provides the definition
5064 of `f', once C has been instantiated for some type. So,
5065 old_decl will be the out-of-class template declaration,
5066 while new_friend is the in-class definition.
5068 But, if `f' was called before this point, the
5069 instantiation of `f' will have DECL_TI_ARGS corresponding
5070 to `T' but not to `U', references to which might appear
5071 in the definition of `f'. Previously, the most general
5072 template for an instantiation of `f' was the out-of-class
5073 version; now it is the in-class version. Therefore, we
5074 run through all specialization of `f', adding to their
5075 DECL_TI_ARGS appropriately. In particular, they need a
5076 new set of outer arguments, corresponding to the
5077 arguments for this class instantiation.
5079 The same situation can arise with something like this:
5082 template <class T> class C {
5086 when `C<int>' is instantiated. Now, `f(int)' is defined
5089 if (!new_friend_is_defn)
5090 /* On the other hand, if the in-class declaration does
5091 *not* provide a definition, then we don't want to alter
5092 existing definitions. We can just leave everything
5097 /* Overwrite whatever template info was there before, if
5098 any, with the new template information pertaining to
5100 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5102 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5103 reregister_specialization (new_friend,
5104 most_general_template (old_decl),
5109 tree new_friend_args;
5111 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5112 = new_friend_result_template_info;
5114 new_friend_args = TI_ARGS (new_friend_template_info);
5115 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5119 tree spec = TREE_VALUE (t);
5122 = add_outermost_template_args (new_friend_args,
5123 DECL_TI_ARGS (spec));
5126 /* Now, since specializations are always supposed to
5127 hang off of the most general template, we must move
5129 t = most_general_template (old_decl);
5132 DECL_TEMPLATE_SPECIALIZATIONS (t)
5133 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5134 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5135 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5140 /* The information from NEW_FRIEND has been merged into OLD_DECL
5141 by duplicate_decls. */
5142 new_friend = old_decl;
5145 else if (COMPLETE_TYPE_P (DECL_CONTEXT (new_friend)))
5147 /* Check to see that the declaration is really present, and,
5148 possibly obtain an improved declaration. */
5149 tree fn = check_classfn (DECL_CONTEXT (new_friend),
5157 input_location = saved_loc;
5161 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5162 template arguments, as for tsubst.
5164 Returns an appropriate tsubst'd friend type or error_mark_node on
5168 tsubst_friend_class (tree friend_tmpl, tree args)
5174 context = DECL_CONTEXT (friend_tmpl);
5178 if (TREE_CODE (context) == NAMESPACE_DECL)
5179 push_nested_namespace (context);
5181 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5184 /* First, we look for a class template. */
5185 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0);
5187 /* But, if we don't find one, it might be because we're in a
5188 situation like this:
5196 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5197 for `S<int>', not the TEMPLATE_DECL. */
5198 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5200 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1);
5201 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5204 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5206 /* The friend template has already been declared. Just
5207 check to see that the declarations match, and install any new
5208 default parameters. We must tsubst the default parameters,
5209 of course. We only need the innermost template parameters
5210 because that is all that redeclare_class_template will look
5212 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5213 > TMPL_ARGS_DEPTH (args))
5216 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5217 args, tf_error | tf_warning);
5218 redeclare_class_template (TREE_TYPE (tmpl), parms);
5221 friend_type = TREE_TYPE (tmpl);
5225 /* The friend template has not already been declared. In this
5226 case, the instantiation of the template class will cause the
5227 injection of this template into the global scope. */
5228 tmpl = tsubst (friend_tmpl, args, tf_error | tf_warning, NULL_TREE);
5230 /* The new TMPL is not an instantiation of anything, so we
5231 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5232 the new type because that is supposed to be the corresponding
5233 template decl, i.e., TMPL. */
5234 DECL_USE_TEMPLATE (tmpl) = 0;
5235 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5236 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5237 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5238 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5240 /* Inject this template into the global scope. */
5241 friend_type = TREE_TYPE (pushdecl_top_level (tmpl));
5246 if (TREE_CODE (context) == NAMESPACE_DECL)
5247 pop_nested_namespace (context);
5249 pop_nested_class ();
5255 /* Returns zero if TYPE cannot be completed later due to circularity.
5256 Otherwise returns one. */
5259 can_complete_type_without_circularity (tree type)
5261 if (type == NULL_TREE || type == error_mark_node)
5263 else if (COMPLETE_TYPE_P (type))
5265 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5266 return can_complete_type_without_circularity (TREE_TYPE (type));
5267 else if (CLASS_TYPE_P (type)
5268 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5275 instantiate_class_template (tree type)
5277 tree template, args, pattern, t, member;
5281 if (type == error_mark_node)
5282 return error_mark_node;
5284 if (TYPE_BEING_DEFINED (type)
5285 || COMPLETE_TYPE_P (type)
5286 || dependent_type_p (type))
5289 /* Figure out which template is being instantiated. */
5290 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5291 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279);
5293 /* Figure out which arguments are being used to do the
5295 args = CLASSTYPE_TI_ARGS (type);
5297 /* Determine what specialization of the original template to
5299 t = most_specialized_class (template, args);
5300 if (t == error_mark_node)
5302 const char *str = "candidates are:";
5303 error ("ambiguous class template instantiation for `%#T'", type);
5304 for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t;
5307 if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args))
5309 cp_error_at ("%s %+#T", str, TREE_TYPE (t));
5313 TYPE_BEING_DEFINED (type) = 1;
5314 return error_mark_node;
5318 pattern = TREE_TYPE (t);
5320 pattern = TREE_TYPE (template);
5322 /* If the template we're instantiating is incomplete, then clearly
5323 there's nothing we can do. */
5324 if (!COMPLETE_TYPE_P (pattern))
5327 /* If we've recursively instantiated too many templates, stop. */
5328 if (! push_tinst_level (type))
5331 /* Now we're really doing the instantiation. Mark the type as in
5332 the process of being defined. */
5333 TYPE_BEING_DEFINED (type) = 1;
5335 /* We may be in the middle of deferred access check. Disable
5337 push_deferring_access_checks (dk_no_deferred);
5339 push_to_top_level ();
5343 /* This TYPE is actually an instantiation of a partial
5344 specialization. We replace the innermost set of ARGS with
5345 the arguments appropriate for substitution. For example,
5348 template <class T> struct S {};
5349 template <class T> struct S<T*> {};
5351 and supposing that we are instantiating S<int*>, ARGS will
5352 present be {int*} but we need {int}. */
5354 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t),
5357 /* If there were multiple levels in ARGS, replacing the
5358 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
5359 want, so we make a copy first. */
5360 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
5362 args = copy_node (args);
5363 SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args);
5369 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5371 /* Set the input location to the template definition. This is needed
5372 if tsubsting causes an error. */
5373 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (pattern));
5375 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5376 TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern);
5377 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5378 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5379 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5380 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5381 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5382 TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern);
5383 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5384 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5385 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5386 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5387 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
5388 = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (pattern);
5389 TYPE_USES_MULTIPLE_INHERITANCE (type)
5390 = TYPE_USES_MULTIPLE_INHERITANCE (pattern);
5391 TYPE_USES_VIRTUAL_BASECLASSES (type)
5392 = TYPE_USES_VIRTUAL_BASECLASSES (pattern);
5393 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5394 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5395 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5396 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5397 if (ANON_AGGR_TYPE_P (pattern))
5398 SET_ANON_AGGR_TYPE_P (type);
5400 pbinfo = TYPE_BINFO (pattern);
5402 #ifdef ENABLE_CHECKING
5403 if (DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5404 && ! COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5405 && ! TYPE_BEING_DEFINED (TYPE_CONTEXT (type)))
5406 /* We should never instantiate a nested class before its enclosing
5407 class; we need to look up the nested class by name before we can
5408 instantiate it, and that lookup should instantiate the enclosing
5413 if (BINFO_BASETYPES (pbinfo))
5415 tree base_list = NULL_TREE;
5416 tree pbases = BINFO_BASETYPES (pbinfo);
5417 tree paccesses = BINFO_BASEACCESSES (pbinfo);
5418 tree context = TYPE_CONTEXT (type);
5422 /* We must enter the scope containing the type, as that is where
5423 the accessibility of types named in dependent bases are
5425 pop_p = push_scope (context ? context : global_namespace);
5427 /* Substitute into each of the bases to determine the actual
5429 for (i = 0; i < TREE_VEC_LENGTH (pbases); ++i)
5435 pbase = TREE_VEC_ELT (pbases, i);
5436 access = TREE_VEC_ELT (paccesses, i);
5438 /* Substitute to figure out the base class. */
5439 base = tsubst (BINFO_TYPE (pbase), args, tf_error, NULL_TREE);
5440 if (base == error_mark_node)
5443 base_list = tree_cons (access, base, base_list);
5444 TREE_VIA_VIRTUAL (base_list) = TREE_VIA_VIRTUAL (pbase);
5447 /* The list is now in reverse order; correct that. */
5448 base_list = nreverse (base_list);
5450 /* Now call xref_basetypes to set up all the base-class
5452 xref_basetypes (type, base_list);
5455 pop_scope (context ? context : global_namespace);
5458 /* Now that our base classes are set up, enter the scope of the
5459 class, so that name lookups into base classes, etc. will work
5460 correctly. This is precisely analogous to what we do in
5461 begin_class_definition when defining an ordinary non-template
5465 /* Now members are processed in the order of declaration. */
5466 for (member = CLASSTYPE_DECL_LIST (pattern);
5467 member; member = TREE_CHAIN (member))
5469 tree t = TREE_VALUE (member);
5471 if (TREE_PURPOSE (member))
5475 /* Build new CLASSTYPE_NESTED_UTDS. */
5478 tree name = TYPE_IDENTIFIER (tag);
5480 bool class_template_p;
5482 class_template_p = (TREE_CODE (tag) != ENUMERAL_TYPE
5483 && TYPE_LANG_SPECIFIC (tag)
5484 && CLASSTYPE_IS_TEMPLATE (tag));
5485 /* If the member is a class template, then -- even after
5486 substituition -- there may be dependent types in the
5487 template argument list for the class. We increment
5488 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5489 that function will assume that no types are dependent
5490 when outside of a template. */
5491 if (class_template_p)
5492 ++processing_template_decl;
5493 newtag = tsubst (tag, args, tf_error, NULL_TREE);
5494 if (class_template_p)
5495 --processing_template_decl;
5496 if (newtag == error_mark_node)
5499 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5501 if (class_template_p)
5502 /* Unfortunately, lookup_template_class sets
5503 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5504 instantiation (i.e., for the type of a member
5505 template class nested within a template class.)
5506 This behavior is required for
5507 maybe_process_partial_specialization to work
5508 correctly, but is not accurate in this case;
5509 the TAG is not an instantiation of anything.
5510 (The corresponding TEMPLATE_DECL is an
5511 instantiation, but the TYPE is not.) */
5512 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5514 /* Now, we call pushtag to put this NEWTAG into the scope of
5515 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5516 pushtag calling push_template_decl. We don't have to do
5517 this for enums because it will already have been done in
5520 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5521 pushtag (name, newtag, /*globalize=*/0);
5524 else if (TREE_CODE (t) == FUNCTION_DECL
5525 || DECL_FUNCTION_TEMPLATE_P (t))
5527 /* Build new TYPE_METHODS. */
5530 if (TREE_CODE (t) == TEMPLATE_DECL)
5531 ++processing_template_decl;
5532 r = tsubst (t, args, tf_error, NULL_TREE);
5533 if (TREE_CODE (t) == TEMPLATE_DECL)
5534 --processing_template_decl;
5535 set_current_access_from_decl (r);
5536 grok_special_member_properties (r);
5537 finish_member_declaration (r);
5541 /* Build new TYPE_FIELDS. */
5543 if (TREE_CODE (t) != CONST_DECL)
5547 /* The the file and line for this declaration, to
5548 assist in error message reporting. Since we
5549 called push_tinst_level above, we don't need to
5551 input_location = DECL_SOURCE_LOCATION (t);
5553 if (TREE_CODE (t) == TEMPLATE_DECL)
5554 ++processing_template_decl;
5555 r = tsubst (t, args, tf_error | tf_warning, NULL_TREE);
5556 if (TREE_CODE (t) == TEMPLATE_DECL)
5557 --processing_template_decl;
5558 if (TREE_CODE (r) == VAR_DECL)
5562 if (DECL_INITIALIZED_IN_CLASS_P (r))
5563 init = tsubst_expr (DECL_INITIAL (t), args,
5564 tf_error | tf_warning, NULL_TREE);
5568 finish_static_data_member_decl
5569 (r, init, /*asmspec_tree=*/NULL_TREE, /*flags=*/0);
5571 if (DECL_INITIALIZED_IN_CLASS_P (r))
5572 check_static_variable_definition (r, TREE_TYPE (r));
5574 else if (TREE_CODE (r) == FIELD_DECL)
5576 /* Determine whether R has a valid type and can be
5577 completed later. If R is invalid, then it is
5578 replaced by error_mark_node so that it will not be
5579 added to TYPE_FIELDS. */
5580 tree rtype = TREE_TYPE (r);
5581 if (can_complete_type_without_circularity (rtype))
5582 complete_type (rtype);
5584 if (!COMPLETE_TYPE_P (rtype))
5586 cxx_incomplete_type_error (r, rtype);
5587 r = error_mark_node;
5591 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5592 such a thing will already have been added to the field
5593 list by tsubst_enum in finish_member_declaration in the
5594 CLASSTYPE_NESTED_UTDS case above. */
5595 if (!(TREE_CODE (r) == TYPE_DECL
5596 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5597 && DECL_ARTIFICIAL (r)))
5599 set_current_access_from_decl (r);
5600 finish_member_declaration (r);
5607 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5609 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5611 tree friend_type = t;
5612 tree new_friend_type;
5614 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5615 new_friend_type = tsubst_friend_class (friend_type, args);
5616 else if (uses_template_parms (friend_type))
5617 new_friend_type = tsubst (friend_type, args,
5618 tf_error | tf_warning, NULL_TREE);
5619 else if (CLASSTYPE_USE_TEMPLATE (friend_type))
5620 new_friend_type = friend_type;
5623 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
5625 /* The call to xref_tag_from_type does injection for friend
5627 push_nested_namespace (ns);
5629 xref_tag_from_type (friend_type, NULL_TREE, 1);
5630 pop_nested_namespace (ns);
5633 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5634 /* Trick make_friend_class into realizing that the friend
5635 we're adding is a template, not an ordinary class. It's
5636 important that we use make_friend_class since it will
5637 perform some error-checking and output cross-reference
5639 ++processing_template_decl;
5641 if (new_friend_type != error_mark_node)
5642 make_friend_class (type, new_friend_type,
5643 /*complain=*/false);
5645 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5646 --processing_template_decl;
5650 /* Build new DECL_FRIENDLIST. */
5653 if (TREE_CODE (t) == TEMPLATE_DECL)
5654 ++processing_template_decl;
5655 r = tsubst_friend_function (t, args);
5656 if (TREE_CODE (t) == TEMPLATE_DECL)
5657 --processing_template_decl;
5658 add_friend (type, r, /*complain=*/false);
5663 /* Set the file and line number information to whatever is given for
5664 the class itself. This puts error messages involving generated
5665 implicit functions at a predictable point, and the same point
5666 that would be used for non-template classes. */
5667 typedecl = TYPE_MAIN_DECL (type);
5668 input_location = DECL_SOURCE_LOCATION (typedecl);
5670 unreverse_member_declarations (type);
5671 finish_struct_1 (type);
5673 /* Clear this now so repo_template_used is happy. */
5674 TYPE_BEING_DEFINED (type) = 0;
5675 repo_template_used (type);
5677 /* Now that the class is complete, instantiate default arguments for
5678 any member functions. We don't do this earlier because the
5679 default arguments may reference members of the class. */
5680 if (!PRIMARY_TEMPLATE_P (template))
5681 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
5682 if (TREE_CODE (t) == FUNCTION_DECL
5683 /* Implicitly generated member functions will not have template
5684 information; they are not instantiations, but instead are
5685 created "fresh" for each instantiation. */
5686 && DECL_TEMPLATE_INFO (t))
5687 tsubst_default_arguments (t);
5690 pop_from_top_level ();
5691 pop_deferring_access_checks ();
5694 if (TYPE_CONTAINS_VPTR_P (type))
5695 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
5701 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
5707 else if (TYPE_P (t))
5708 r = tsubst (t, args, complain, in_decl);
5711 r = tsubst_expr (t, args, complain, in_decl);
5713 if (!uses_template_parms (r))
5715 /* Sometimes, one of the args was an expression involving a
5716 template constant parameter, like N - 1. Now that we've
5717 tsubst'd, we might have something like 2 - 1. This will
5718 confuse lookup_template_class, so we do constant folding
5719 here. We have to unset processing_template_decl, to fool
5720 tsubst_copy_and_build() into building an actual tree. */
5722 /* If the TREE_TYPE of ARG is not NULL_TREE, ARG is already
5723 as simple as it's going to get, and trying to reprocess
5724 the trees will break. Once tsubst_expr et al DTRT for
5725 non-dependent exprs, this code can go away, as the type
5726 will always be set. */
5729 int saved_processing_template_decl = processing_template_decl;
5730 processing_template_decl = 0;
5731 r = tsubst_copy_and_build (r, /*args=*/NULL_TREE,
5732 tf_error, /*in_decl=*/NULL_TREE,
5733 /*function_p=*/false);
5734 processing_template_decl = saved_processing_template_decl;
5742 /* Substitute ARGS into the vector or list of template arguments T. */
5745 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
5747 int len = TREE_VEC_LENGTH (t);
5748 int need_new = 0, i;
5749 tree *elts = alloca (len * sizeof (tree));
5751 for (i = 0; i < len; i++)
5753 tree orig_arg = TREE_VEC_ELT (t, i);
5756 if (TREE_CODE (orig_arg) == TREE_VEC)
5757 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
5759 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
5761 if (new_arg == error_mark_node)
5762 return error_mark_node;
5765 if (new_arg != orig_arg)
5772 t = make_tree_vec (len);
5773 for (i = 0; i < len; i++)
5774 TREE_VEC_ELT (t, i) = elts[i];
5779 /* Return the result of substituting ARGS into the template parameters
5780 given by PARMS. If there are m levels of ARGS and m + n levels of
5781 PARMS, then the result will contain n levels of PARMS. For
5782 example, if PARMS is `template <class T> template <class U>
5783 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5784 result will be `template <int*, double, class V>'. */
5787 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
5792 /* When substituting into a template, we must set
5793 PROCESSING_TEMPLATE_DECL as the template parameters may be
5794 dependent if they are based on one-another, and the dependency
5795 predicates are short-circuit outside of templates. */
5796 ++processing_template_decl;
5798 for (new_parms = &r;
5799 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
5800 new_parms = &(TREE_CHAIN (*new_parms)),
5801 parms = TREE_CHAIN (parms))
5804 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
5807 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
5809 tree tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
5810 tree default_value = TREE_PURPOSE (tuple);
5811 tree parm_decl = TREE_VALUE (tuple);
5813 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
5814 default_value = tsubst_template_arg (default_value, args,
5815 complain, NULL_TREE);
5817 tuple = build_tree_list (default_value, parm_decl);
5818 TREE_VEC_ELT (new_vec, i) = tuple;
5822 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
5823 - TMPL_ARGS_DEPTH (args)),
5824 new_vec, NULL_TREE);
5827 --processing_template_decl;
5832 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5833 type T. If T is not an aggregate or enumeration type, it is
5834 handled as if by tsubst. IN_DECL is as for tsubst. If
5835 ENTERING_SCOPE is nonzero, T is the context for a template which
5836 we are presently tsubst'ing. Return the substituted value. */
5839 tsubst_aggr_type (tree t,
5841 tsubst_flags_t complain,
5848 switch (TREE_CODE (t))
5851 if (TYPE_PTRMEMFUNC_P (t))
5852 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
5854 /* Else fall through. */
5857 if (TYPE_TEMPLATE_INFO (t))
5863 /* First, determine the context for the type we are looking
5865 context = TYPE_CONTEXT (t);
5867 context = tsubst_aggr_type (context, args, complain,
5868 in_decl, /*entering_scope=*/1);
5870 /* Then, figure out what arguments are appropriate for the
5871 type we are trying to find. For example, given:
5873 template <class T> struct S;
5874 template <class T, class U> void f(T, U) { S<U> su; }
5876 and supposing that we are instantiating f<int, double>,
5877 then our ARGS will be {int, double}, but, when looking up
5878 S we only want {double}. */
5879 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
5881 if (argvec == error_mark_node)
5882 return error_mark_node;
5884 r = lookup_template_class (t, argvec, in_decl, context,
5885 entering_scope, complain);
5887 return cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
5890 /* This is not a template type, so there's nothing to do. */
5894 return tsubst (t, args, complain, in_decl);
5898 /* Substitute into the default argument ARG (a default argument for
5899 FN), which has the indicated TYPE. */
5902 tsubst_default_argument (tree fn, tree type, tree arg)
5904 tree saved_class_ptr = NULL_TREE;
5905 tree saved_class_ref = NULL_TREE;
5907 /* This default argument came from a template. Instantiate the
5908 default argument here, not in tsubst. In the case of
5917 we must be careful to do name lookup in the scope of S<T>,
5918 rather than in the current class. */
5919 push_access_scope (fn);
5920 /* The default argument expression should not be considered to be
5921 within the scope of FN. Since push_access_scope sets
5922 current_function_decl, we must explicitly clear it here. */
5923 current_function_decl = NULL_TREE;
5924 /* The "this" pointer is not valid in a default argument. */
5927 saved_class_ptr = current_class_ptr;
5928 cp_function_chain->x_current_class_ptr = NULL_TREE;
5929 saved_class_ref = current_class_ref;
5930 cp_function_chain->x_current_class_ref = NULL_TREE;
5933 push_deferring_access_checks(dk_no_deferred);
5934 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
5935 tf_error | tf_warning, NULL_TREE);
5936 pop_deferring_access_checks();
5938 /* Restore the "this" pointer. */
5941 cp_function_chain->x_current_class_ptr = saved_class_ptr;
5942 cp_function_chain->x_current_class_ref = saved_class_ref;
5945 pop_access_scope (fn);
5947 /* Make sure the default argument is reasonable. */
5948 arg = check_default_argument (type, arg);
5953 /* Substitute into all the default arguments for FN. */
5956 tsubst_default_arguments (tree fn)
5961 tmpl_args = DECL_TI_ARGS (fn);
5963 /* If this function is not yet instantiated, we certainly don't need
5964 its default arguments. */
5965 if (uses_template_parms (tmpl_args))
5968 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
5970 arg = TREE_CHAIN (arg))
5971 if (TREE_PURPOSE (arg))
5972 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
5974 TREE_PURPOSE (arg));
5977 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5978 (already computed) substitution of ARGS into TREE_TYPE (T), if
5979 appropriate. Return the result of the substitution. Issue error
5980 and warning messages under control of COMPLAIN. */
5983 tsubst_decl (tree t, tree args, tree type, tsubst_flags_t complain)
5985 location_t saved_loc;
5989 /* Set the filename and linenumber to improve error-reporting. */
5990 saved_loc = input_location;
5991 input_location = DECL_SOURCE_LOCATION (t);
5993 switch (TREE_CODE (t))
5997 /* We can get here when processing a member template function
5998 of a template class. */
5999 tree decl = DECL_TEMPLATE_RESULT (t);
6001 int is_template_template_parm = DECL_TEMPLATE_TEMPLATE_PARM_P (t);
6003 if (!is_template_template_parm)
6005 /* We might already have an instance of this template.
6006 The ARGS are for the surrounding class type, so the
6007 full args contain the tsubst'd args for the context,
6008 plus the innermost args from the template decl. */
6009 tree tmpl_args = DECL_CLASS_TEMPLATE_P (t)
6010 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
6011 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
6014 /* Because this is a template, the arguments will still be
6015 dependent, even after substitution. If
6016 PROCESSING_TEMPLATE_DECL is not set, the dependency
6017 predicates will short-circuit. */
6018 ++processing_template_decl;
6019 full_args = tsubst_template_args (tmpl_args, args,
6021 --processing_template_decl;
6023 /* tsubst_template_args doesn't copy the vector if
6024 nothing changed. But, *something* should have
6026 my_friendly_assert (full_args != tmpl_args, 0);
6028 spec = retrieve_specialization (t, full_args);
6029 if (spec != NULL_TREE)
6036 /* Make a new template decl. It will be similar to the
6037 original, but will record the current template arguments.
6038 We also create a new function declaration, which is just
6039 like the old one, but points to this new template, rather
6040 than the old one. */
6042 my_friendly_assert (DECL_LANG_SPECIFIC (r) != 0, 0);
6043 TREE_CHAIN (r) = NULL_TREE;
6045 if (is_template_template_parm)
6047 tree new_decl = tsubst (decl, args, complain, in_decl);
6048 DECL_TEMPLATE_RESULT (r) = new_decl;
6049 TREE_TYPE (r) = TREE_TYPE (new_decl);
6053 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6055 if (TREE_CODE (decl) == TYPE_DECL)
6058 ++processing_template_decl;
6059 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6060 --processing_template_decl;
6061 if (new_type == error_mark_node)
6062 return error_mark_node;
6064 TREE_TYPE (r) = new_type;
6065 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6066 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6067 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6068 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
6073 ++processing_template_decl;
6074 new_decl = tsubst (decl, args, complain, in_decl);
6075 --processing_template_decl;
6076 if (new_decl == error_mark_node)
6077 return error_mark_node;
6079 DECL_TEMPLATE_RESULT (r) = new_decl;
6080 DECL_TI_TEMPLATE (new_decl) = r;
6081 TREE_TYPE (r) = TREE_TYPE (new_decl);
6082 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6083 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
6086 SET_DECL_IMPLICIT_INSTANTIATION (r);
6087 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6088 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6090 /* The template parameters for this new template are all the
6091 template parameters for the old template, except the
6092 outermost level of parameters. */
6093 DECL_TEMPLATE_PARMS (r)
6094 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6097 if (PRIMARY_TEMPLATE_P (t))
6098 DECL_PRIMARY_TEMPLATE (r) = r;
6100 if (TREE_CODE (decl) != TYPE_DECL)
6101 /* Record this non-type partial instantiation. */
6102 register_specialization (r, t,
6103 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)));
6110 tree argvec = NULL_TREE;
6117 /* Nobody should be tsubst'ing into non-template functions. */
6118 my_friendly_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE, 0);
6120 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6125 /* If T is not dependent, just return it. We have to
6126 increment PROCESSING_TEMPLATE_DECL because
6127 value_dependent_expression_p assumes that nothing is
6128 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6129 ++processing_template_decl;
6130 dependent_p = value_dependent_expression_p (t);
6131 --processing_template_decl;
6135 /* Calculate the most general template of which R is a
6136 specialization, and the complete set of arguments used to
6138 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6139 argvec = tsubst_template_args (DECL_TI_ARGS
6140 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6141 args, complain, in_decl);
6143 /* Check to see if we already have this specialization. */
6144 spec = retrieve_specialization (gen_tmpl, argvec);
6152 /* We can see more levels of arguments than parameters if
6153 there was a specialization of a member template, like
6156 template <class T> struct S { template <class U> void f(); }
6157 template <> template <class U> void S<int>::f(U);
6159 Here, we'll be substituting into the specialization,
6160 because that's where we can find the code we actually
6161 want to generate, but we'll have enough arguments for
6162 the most general template.
6164 We also deal with the peculiar case:
6166 template <class T> struct S {
6167 template <class U> friend void f();
6169 template <class U> void f() {}
6171 template void f<double>();
6173 Here, the ARGS for the instantiation of will be {int,
6174 double}. But, we only need as many ARGS as there are
6175 levels of template parameters in CODE_PATTERN. We are
6176 careful not to get fooled into reducing the ARGS in
6179 template <class T> struct S { template <class U> void f(U); }
6180 template <class T> template <> void S<T>::f(int) {}
6182 which we can spot because the pattern will be a
6183 specialization in this case. */
6184 args_depth = TMPL_ARGS_DEPTH (args);
6186 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6187 if (args_depth > parms_depth
6188 && !DECL_TEMPLATE_SPECIALIZATION (t))
6189 args = get_innermost_template_args (args, parms_depth);
6193 /* This special case arises when we have something like this:
6195 template <class T> struct S {
6196 friend void f<int>(int, double);
6199 Here, the DECL_TI_TEMPLATE for the friend declaration
6200 will be an IDENTIFIER_NODE. We are being called from
6201 tsubst_friend_function, and we want only to create a
6202 new decl (R) with appropriate types so that we can call
6203 determine_specialization. */
6204 gen_tmpl = NULL_TREE;
6207 if (DECL_CLASS_SCOPE_P (t))
6209 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6213 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6214 complain, t, /*entering_scope=*/1);
6219 ctx = DECL_CONTEXT (t);
6221 type = tsubst (type, args, complain, in_decl);
6222 if (type == error_mark_node)
6223 return error_mark_node;
6225 /* We do NOT check for matching decls pushed separately at this
6226 point, as they may not represent instantiations of this
6227 template, and in any case are considered separate under the
6230 DECL_USE_TEMPLATE (r) = 0;
6231 TREE_TYPE (r) = type;
6232 /* Clear out the mangled name and RTL for the instantiation. */
6233 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6234 SET_DECL_RTL (r, NULL_RTX);
6235 DECL_INITIAL (r) = NULL_TREE;
6236 DECL_CONTEXT (r) = ctx;
6238 if (member && DECL_CONV_FN_P (r))
6239 /* Type-conversion operator. Reconstruct the name, in
6240 case it's the name of one of the template's parameters. */
6241 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6243 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6245 DECL_RESULT (r) = NULL_TREE;
6247 TREE_STATIC (r) = 0;
6248 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6249 DECL_EXTERNAL (r) = 1;
6250 DECL_INTERFACE_KNOWN (r) = 0;
6251 DECL_DEFER_OUTPUT (r) = 0;
6252 TREE_CHAIN (r) = NULL_TREE;
6253 DECL_PENDING_INLINE_INFO (r) = 0;
6254 DECL_PENDING_INLINE_P (r) = 0;
6255 DECL_SAVED_TREE (r) = NULL_TREE;
6257 if (DECL_CLONED_FUNCTION (r))
6259 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6261 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6262 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6265 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6266 this in the special friend case mentioned above where
6267 GEN_TMPL is NULL. */
6270 DECL_TEMPLATE_INFO (r)
6271 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6272 SET_DECL_IMPLICIT_INSTANTIATION (r);
6273 register_specialization (r, gen_tmpl, argvec);
6275 /* We're not supposed to instantiate default arguments
6276 until they are called, for a template. But, for a
6279 template <class T> void f ()
6280 { extern void g(int i = T()); }
6282 we should do the substitution when the template is
6283 instantiated. We handle the member function case in
6284 instantiate_class_template since the default arguments
6285 might refer to other members of the class. */
6287 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6288 && !uses_template_parms (argvec))
6289 tsubst_default_arguments (r);
6292 /* Copy the list of befriending classes. */
6293 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6295 friends = &TREE_CHAIN (*friends))
6297 *friends = copy_node (*friends);
6298 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6303 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6305 maybe_retrofit_in_chrg (r);
6306 if (DECL_CONSTRUCTOR_P (r))
6307 grok_ctor_properties (ctx, r);
6308 /* If this is an instantiation of a member template, clone it.
6309 If it isn't, that'll be handled by
6310 clone_constructors_and_destructors. */
6311 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6312 clone_function_decl (r, /*update_method_vec_p=*/0);
6314 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r)))
6315 grok_op_properties (r, (complain & tf_error) != 0);
6317 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6318 SET_DECL_FRIEND_CONTEXT (r,
6319 tsubst (DECL_FRIEND_CONTEXT (t),
6320 args, complain, in_decl));
6327 if (DECL_TEMPLATE_PARM_P (t))
6328 SET_DECL_TEMPLATE_PARM_P (r);
6330 TREE_TYPE (r) = type;
6331 c_apply_type_quals_to_decl (cp_type_quals (type), r);
6333 if (DECL_INITIAL (r))
6335 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6336 DECL_INITIAL (r) = TREE_TYPE (r);
6338 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6342 DECL_CONTEXT (r) = NULL_TREE;
6344 if (!DECL_TEMPLATE_PARM_P (r))
6345 DECL_ARG_TYPE (r) = type_passed_as (type);
6347 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6348 complain, TREE_CHAIN (t));
6355 TREE_TYPE (r) = type;
6356 c_apply_type_quals_to_decl (cp_type_quals (type), r);
6358 /* We don't have to set DECL_CONTEXT here; it is set by
6359 finish_member_declaration. */
6360 DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args,
6362 TREE_CHAIN (r) = NULL_TREE;
6363 if (VOID_TYPE_P (type))
6364 cp_error_at ("instantiation of `%D' as type `%T'", r, type);
6371 /* It is not a dependent using decl any more. */
6372 TREE_TYPE (r) = void_type_node;
6374 = tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
6376 = tsubst_copy (DECL_NAME (t), args, complain, in_decl);
6377 TREE_CHAIN (r) = NULL_TREE;
6382 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6383 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6385 /* If this is the canonical decl, we don't have to mess with
6386 instantiations, and often we can't (for typename, template
6387 type parms and such). Note that TYPE_NAME is not correct for
6388 the above test if we've copied the type for a typedef. */
6389 r = TYPE_NAME (type);
6397 tree argvec = NULL_TREE;
6398 tree gen_tmpl = NULL_TREE;
6400 tree tmpl = NULL_TREE;
6404 /* Assume this is a non-local variable. */
6407 if (TYPE_P (CP_DECL_CONTEXT (t)))
6408 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6410 in_decl, /*entering_scope=*/1);
6411 else if (DECL_NAMESPACE_SCOPE_P (t))
6412 ctx = DECL_CONTEXT (t);
6415 /* Subsequent calls to pushdecl will fill this in. */
6420 /* Check to see if we already have this specialization. */
6423 tmpl = DECL_TI_TEMPLATE (t);
6424 gen_tmpl = most_general_template (tmpl);
6425 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6426 spec = retrieve_specialization (gen_tmpl, argvec);
6429 spec = retrieve_local_specialization (t);
6438 if (TREE_CODE (r) == VAR_DECL)
6440 type = complete_type (type);
6441 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6442 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6443 type = check_var_type (DECL_NAME (r), type);
6445 else if (DECL_SELF_REFERENCE_P (t))
6446 SET_DECL_SELF_REFERENCE_P (r);
6447 TREE_TYPE (r) = type;
6448 c_apply_type_quals_to_decl (cp_type_quals (type), r);
6449 DECL_CONTEXT (r) = ctx;
6450 /* Clear out the mangled name and RTL for the instantiation. */
6451 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6452 SET_DECL_RTL (r, NULL_RTX);
6454 /* Don't try to expand the initializer until someone tries to use
6455 this variable; otherwise we run into circular dependencies. */
6456 DECL_INITIAL (r) = NULL_TREE;
6457 SET_DECL_RTL (r, NULL_RTX);
6458 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
6460 /* Even if the original location is out of scope, the newly
6461 substituted one is not. */
6462 if (TREE_CODE (r) == VAR_DECL)
6464 DECL_DEAD_FOR_LOCAL (r) = 0;
6465 DECL_INITIALIZED_P (r) = 0;
6470 /* A static data member declaration is always marked
6471 external when it is declared in-class, even if an
6472 initializer is present. We mimic the non-template
6474 DECL_EXTERNAL (r) = 1;
6476 register_specialization (r, gen_tmpl, argvec);
6477 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
6478 SET_DECL_IMPLICIT_INSTANTIATION (r);
6481 register_local_specialization (r, t);
6483 TREE_CHAIN (r) = NULL_TREE;
6492 /* Restore the file and line information. */
6493 input_location = saved_loc;
6498 /* Substitute into the ARG_TYPES of a function type. */
6501 tsubst_arg_types (tree arg_types,
6503 tsubst_flags_t complain,
6506 tree remaining_arg_types;
6509 tree result = NULL_TREE;
6511 if (!arg_types || arg_types == void_list_node)
6514 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
6515 args, complain, in_decl);
6516 if (remaining_arg_types == error_mark_node)
6517 return error_mark_node;
6519 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
6520 if (type == error_mark_node)
6521 return error_mark_node;
6522 if (VOID_TYPE_P (type))
6524 if (complain & tf_error)
6526 error ("invalid parameter type `%T'", type);
6528 cp_error_at ("in declaration `%D'", in_decl);
6530 return error_mark_node;
6533 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6534 top-level qualifiers as required. */
6535 type = TYPE_MAIN_VARIANT (type_decays_to (type));
6537 /* We do not substitute into default arguments here. The standard
6538 mandates that they be instantiated only when needed, which is
6539 done in build_over_call. */
6540 default_arg = TREE_PURPOSE (arg_types);
6542 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
6544 /* We've instantiated a template before its default arguments
6545 have been parsed. This can happen for a nested template
6546 class, and is not an error unless we require the default
6547 argument in a call of this function. */
6548 result = tree_cons (default_arg, type, remaining_arg_types);
6549 TREE_CHAIN (default_arg) = tree_cons (result, NULL_TREE,
6550 TREE_CHAIN (default_arg));
6553 result = hash_tree_cons (default_arg, type, remaining_arg_types);
6558 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6559 *not* handle the exception-specification for FNTYPE, because the
6560 initial substitution of explicitly provided template parameters
6561 during argument deduction forbids substitution into the
6562 exception-specification:
6566 All references in the function type of the function template to the
6567 corresponding template parameters are replaced by the specified tem-
6568 plate argument values. If a substitution in a template parameter or
6569 in the function type of the function template results in an invalid
6570 type, type deduction fails. [Note: The equivalent substitution in
6571 exception specifications is done only when the function is instanti-
6572 ated, at which point a program is ill-formed if the substitution
6573 results in an invalid type.] */
6576 tsubst_function_type (tree t,
6578 tsubst_flags_t complain,
6585 /* The TYPE_CONTEXT is not used for function/method types. */
6586 my_friendly_assert (TYPE_CONTEXT (t) == NULL_TREE, 0);
6588 /* Substitute the return type. */
6589 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6590 if (return_type == error_mark_node)
6591 return error_mark_node;
6593 /* Substitute the argument types. */
6594 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
6596 if (arg_types == error_mark_node)
6597 return error_mark_node;
6599 /* Construct a new type node and return it. */
6600 if (TREE_CODE (t) == FUNCTION_TYPE)
6601 fntype = build_function_type (return_type, arg_types);
6604 tree r = TREE_TYPE (TREE_VALUE (arg_types));
6605 if (! IS_AGGR_TYPE (r))
6609 Type deduction may fail for any of the following
6612 -- Attempting to create "pointer to member of T" when T
6613 is not a class type. */
6614 if (complain & tf_error)
6615 error ("creating pointer to member function of non-class type `%T'",
6617 return error_mark_node;
6620 fntype = build_method_type_directly (r, return_type,
6621 TREE_CHAIN (arg_types));
6623 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
6624 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
6629 /* Substitute into the PARMS of a call-declarator. */
6632 tsubst_call_declarator_parms (tree parms,
6634 tsubst_flags_t complain,
6641 if (!parms || parms == void_list_node)
6644 new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms),
6645 args, complain, in_decl);
6647 /* Figure out the type of this parameter. */
6648 type = tsubst (TREE_VALUE (parms), args, complain, in_decl);
6650 /* Figure out the default argument as well. Note that we use
6651 tsubst_expr since the default argument is really an expression. */
6652 defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl);
6654 /* Chain this parameter on to the front of those we have already
6655 processed. We don't use hash_tree_cons because that function
6656 doesn't check TREE_PARMLIST. */
6657 new_parms = tree_cons (defarg, type, new_parms);
6659 /* And note that these are parameters. */
6660 TREE_PARMLIST (new_parms) = 1;
6665 /* Take the tree structure T and replace template parameters used
6666 therein with the argument vector ARGS. IN_DECL is an associated
6667 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6668 Issue error and warning messages under control of COMPLAIN. Note
6669 that we must be relatively non-tolerant of extensions here, in
6670 order to preserve conformance; if we allow substitutions that
6671 should not be allowed, we may allow argument deductions that should
6672 not succeed, and therefore report ambiguous overload situations
6673 where there are none. In theory, we could allow the substitution,
6674 but indicate that it should have failed, and allow our caller to
6675 make sure that the right thing happens, but we don't try to do this
6678 This function is used for dealing with types, decls and the like;
6679 for expressions, use tsubst_expr or tsubst_copy. */
6682 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6686 if (t == NULL_TREE || t == error_mark_node
6687 || t == integer_type_node
6688 || t == void_type_node
6689 || t == char_type_node
6690 || t == unknown_type_node
6691 || TREE_CODE (t) == NAMESPACE_DECL)
6694 if (TREE_CODE (t) == IDENTIFIER_NODE)
6695 type = IDENTIFIER_TYPE_VALUE (t);
6697 type = TREE_TYPE (t);
6699 my_friendly_assert (type != unknown_type_node, 20030716);
6701 if (type && TREE_CODE (t) != FUNCTION_DECL
6702 && TREE_CODE (t) != TYPENAME_TYPE
6703 && TREE_CODE (t) != TEMPLATE_DECL
6704 && TREE_CODE (t) != IDENTIFIER_NODE
6705 && TREE_CODE (t) != FUNCTION_TYPE
6706 && TREE_CODE (t) != METHOD_TYPE)
6707 type = tsubst (type, args, complain, in_decl);
6708 if (type == error_mark_node)
6709 return error_mark_node;
6712 return tsubst_decl (t, args, type, complain);
6714 switch (TREE_CODE (t))
6719 return tsubst_aggr_type (t, args, complain, in_decl,
6720 /*entering_scope=*/0);
6723 case IDENTIFIER_NODE:
6735 if (t == integer_type_node)
6738 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
6739 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
6743 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
6745 /* The array dimension behaves like a non-type template arg,
6746 in that we want to fold it as much as possible. */
6747 max = tsubst_template_arg (omax, args, complain, in_decl);
6748 max = fold_non_dependent_expr (max);
6750 if (integer_zerop (omax))
6752 /* Still allow an explicit array of size zero. */
6754 pedwarn ("creating array with size zero");
6756 else if (integer_zerop (max)
6757 || (TREE_CODE (max) == INTEGER_CST
6758 && INT_CST_LT (max, integer_zero_node)))
6762 Type deduction may fail for any of the following
6765 Attempting to create an array with a size that is
6766 zero or negative. */
6767 if (complain & tf_error)
6768 error ("creating array with size zero (`%E')", max);
6770 return error_mark_node;
6773 return compute_array_index_type (NULL_TREE, max);
6776 case TEMPLATE_TYPE_PARM:
6777 case TEMPLATE_TEMPLATE_PARM:
6778 case BOUND_TEMPLATE_TEMPLATE_PARM:
6779 case TEMPLATE_PARM_INDEX:
6787 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
6788 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
6789 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6791 idx = TEMPLATE_TYPE_IDX (t);
6792 level = TEMPLATE_TYPE_LEVEL (t);
6796 idx = TEMPLATE_PARM_IDX (t);
6797 level = TEMPLATE_PARM_LEVEL (t);
6800 if (TREE_VEC_LENGTH (args) > 0)
6802 tree arg = NULL_TREE;
6804 levels = TMPL_ARGS_DEPTH (args);
6805 if (level <= levels)
6806 arg = TMPL_ARG (args, level, idx);
6808 if (arg == error_mark_node)
6809 return error_mark_node;
6810 else if (arg != NULL_TREE)
6812 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
6814 my_friendly_assert (TYPE_P (arg), 0);
6815 return cp_build_qualified_type_real
6816 (arg, cp_type_quals (arg) | cp_type_quals (t),
6817 complain | tf_ignore_bad_quals);
6819 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6821 /* We are processing a type constructed from
6822 a template template parameter. */
6823 tree argvec = tsubst (TYPE_TI_ARGS (t),
6824 args, complain, in_decl);
6825 if (argvec == error_mark_node)
6826 return error_mark_node;
6828 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6829 we are resolving nested-types in the signature of
6830 a member function templates.
6831 Otherwise ARG is a TEMPLATE_DECL and is the real
6832 template to be instantiated. */
6833 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
6834 arg = TYPE_NAME (arg);
6836 r = lookup_template_class (arg,
6839 /*entering_scope=*/0,
6841 return cp_build_qualified_type_real
6842 (r, TYPE_QUALS (t), complain);
6845 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
6853 /* This can happen during the attempted tsubst'ing in
6854 unify. This means that we don't yet have any information
6855 about the template parameter in question. */
6858 /* If we get here, we must have been looking at a parm for a
6859 more deeply nested template. Make a new version of this
6860 template parameter, but with a lower level. */
6861 switch (TREE_CODE (t))
6863 case TEMPLATE_TYPE_PARM:
6864 case TEMPLATE_TEMPLATE_PARM:
6865 case BOUND_TEMPLATE_TEMPLATE_PARM:
6866 if (cp_type_quals (t))
6868 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
6869 r = cp_build_qualified_type_real
6870 (r, cp_type_quals (t),
6871 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
6872 ? tf_ignore_bad_quals : 0));
6877 TEMPLATE_TYPE_PARM_INDEX (r)
6878 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
6880 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
6881 TYPE_MAIN_VARIANT (r) = r;
6882 TYPE_POINTER_TO (r) = NULL_TREE;
6883 TYPE_REFERENCE_TO (r) = NULL_TREE;
6885 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6887 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
6889 if (argvec == error_mark_node)
6890 return error_mark_node;
6892 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
6893 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
6898 case TEMPLATE_PARM_INDEX:
6899 r = reduce_template_parm_level (t, type, levels);
6911 tree purpose, value, chain, result;
6913 if (t == void_list_node)
6916 purpose = TREE_PURPOSE (t);
6919 purpose = tsubst (purpose, args, complain, in_decl);
6920 if (purpose == error_mark_node)
6921 return error_mark_node;
6923 value = TREE_VALUE (t);
6926 value = tsubst (value, args, complain, in_decl);
6927 if (value == error_mark_node)
6928 return error_mark_node;
6930 chain = TREE_CHAIN (t);
6931 if (chain && chain != void_type_node)
6933 chain = tsubst (chain, args, complain, in_decl);
6934 if (chain == error_mark_node)
6935 return error_mark_node;
6937 if (purpose == TREE_PURPOSE (t)
6938 && value == TREE_VALUE (t)
6939 && chain == TREE_CHAIN (t))
6941 if (TREE_PARMLIST (t))
6943 result = tree_cons (purpose, value, chain);
6944 TREE_PARMLIST (result) = 1;
6947 result = hash_tree_cons (purpose, value, chain);
6951 if (type != NULL_TREE)
6953 /* A binfo node. We always need to make a copy, of the node
6954 itself and of its BINFO_BASETYPES. */
6958 /* Make sure type isn't a typedef copy. */
6959 type = BINFO_TYPE (TYPE_BINFO (type));
6961 TREE_TYPE (t) = complete_type (type);
6962 if (IS_AGGR_TYPE (type))
6964 BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type);
6965 BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type);
6966 if (TYPE_BINFO_BASETYPES (type) != NULL_TREE)
6967 BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type));
6972 /* Otherwise, a vector of template arguments. */
6973 return tsubst_template_args (t, args, complain, in_decl);
6976 case REFERENCE_TYPE:
6978 enum tree_code code;
6980 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
6983 code = TREE_CODE (t);
6988 Type deduction may fail for any of the following
6991 -- Attempting to create a pointer to reference type.
6992 -- Attempting to create a reference to a reference type or
6993 a reference to void. */
6994 if (TREE_CODE (type) == REFERENCE_TYPE
6995 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
6997 static location_t last_loc;
6999 /* We keep track of the last time we issued this error
7000 message to avoid spewing a ton of messages during a
7001 single bad template instantiation. */
7002 if (complain & tf_error
7003 && (last_loc.line != input_line
7004 || last_loc.file != input_filename))
7006 if (TREE_CODE (type) == VOID_TYPE)
7007 error ("forming reference to void");
7009 error ("forming %s to reference type `%T'",
7010 (code == POINTER_TYPE) ? "pointer" : "reference",
7012 last_loc = input_location;
7015 return error_mark_node;
7017 else if (code == POINTER_TYPE)
7019 r = build_pointer_type (type);
7020 if (TREE_CODE (type) == METHOD_TYPE)
7021 r = build_ptrmemfunc_type (r);
7024 r = build_reference_type (type);
7025 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7027 if (r != error_mark_node)
7028 /* Will this ever be needed for TYPE_..._TO values? */
7035 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7036 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7040 Type deduction may fail for any of the following
7043 -- Attempting to create "pointer to member of T" when T
7044 is not a class type. */
7045 if (complain & tf_error)
7046 error ("creating pointer to member of non-class type `%T'", r);
7047 return error_mark_node;
7049 if (TREE_CODE (type) == REFERENCE_TYPE)
7051 if (complain & tf_error)
7052 error ("creating pointer to member reference type `%T'", type);
7054 return error_mark_node;
7056 my_friendly_assert (TREE_CODE (type) != METHOD_TYPE, 20011231);
7057 if (TREE_CODE (type) == FUNCTION_TYPE)
7059 /* This is really a method type. The cv qualifiers of the
7060 this pointer should _not_ be determined by the cv
7061 qualifiers of the class type. They should be held
7062 somewhere in the FUNCTION_TYPE, but we don't do that at
7063 the moment. Consider
7064 typedef void (Func) () const;
7066 template <typename T1> void Foo (Func T1::*);
7071 method_type = build_method_type_directly (TYPE_MAIN_VARIANT (r),
7073 TYPE_ARG_TYPES (type));
7074 return build_ptrmemfunc_type (build_pointer_type (method_type));
7077 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7087 fntype = tsubst_function_type (t, args, complain, in_decl);
7088 if (fntype == error_mark_node)
7089 return error_mark_node;
7091 /* Substitute the exception specification. */
7092 raises = TYPE_RAISES_EXCEPTIONS (t);
7095 tree list = NULL_TREE;
7097 if (! TREE_VALUE (raises))
7100 for (; raises != NULL_TREE; raises = TREE_CHAIN (raises))
7102 tree spec = TREE_VALUE (raises);
7104 spec = tsubst (spec, args, complain, in_decl);
7105 if (spec == error_mark_node)
7107 list = add_exception_specifier (list, spec, complain);
7109 fntype = build_exception_variant (fntype, list);
7115 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7116 if (domain == error_mark_node)
7117 return error_mark_node;
7119 /* As an optimization, we avoid regenerating the array type if
7120 it will obviously be the same as T. */
7121 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7124 /* These checks should match the ones in grokdeclarator.
7128 The deduction may fail for any of the following reasons:
7130 -- Attempting to create an array with an element type that
7131 is void, a function type, or a reference type, or [DR337]
7132 an abstract class type. */
7133 if (TREE_CODE (type) == VOID_TYPE
7134 || TREE_CODE (type) == FUNCTION_TYPE
7135 || TREE_CODE (type) == REFERENCE_TYPE)
7137 if (complain & tf_error)
7138 error ("creating array of `%T'", type);
7139 return error_mark_node;
7141 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7143 if (complain & tf_error)
7144 error ("creating array of `%T', which is an abstract class type",
7146 return error_mark_node;
7149 r = build_cplus_array_type (type, domain);
7156 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7157 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7159 if (e1 == error_mark_node || e2 == error_mark_node)
7160 return error_mark_node;
7162 return fold (build (TREE_CODE (t), TREE_TYPE (t), e1, e2));
7168 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7169 if (e == error_mark_node)
7170 return error_mark_node;
7172 return fold (build (TREE_CODE (t), TREE_TYPE (t), e));
7177 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7178 in_decl, /*entering_scope=*/1);
7179 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7182 if (ctx == error_mark_node || f == error_mark_node)
7183 return error_mark_node;
7185 if (!IS_AGGR_TYPE (ctx))
7187 if (complain & tf_error)
7188 error ("`%T' is not a class, struct, or union type",
7190 return error_mark_node;
7192 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7194 /* Normally, make_typename_type does not require that the CTX
7195 have complete type in order to allow things like:
7197 template <class T> struct S { typename S<T>::X Y; };
7199 But, such constructs have already been resolved by this
7200 point, so here CTX really should have complete type, unless
7201 it's a partial instantiation. */
7202 ctx = complete_type (ctx);
7203 if (!COMPLETE_TYPE_P (ctx))
7205 if (complain & tf_error)
7206 cxx_incomplete_type_error (NULL_TREE, ctx);
7207 return error_mark_node;
7211 f = make_typename_type (ctx, f,
7212 (complain & tf_error) | tf_keep_type_decl);
7213 if (f == error_mark_node)
7215 if (TREE_CODE (f) == TYPE_DECL)
7217 complain |= tf_ignore_bad_quals;
7221 return cp_build_qualified_type_real
7222 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7225 case UNBOUND_CLASS_TEMPLATE:
7227 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7228 in_decl, /*entering_scope=*/1);
7229 tree name = TYPE_IDENTIFIER (t);
7231 if (ctx == error_mark_node || name == error_mark_node)
7232 return error_mark_node;
7234 return make_unbound_class_template (ctx, name, complain);
7239 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7240 if (e == error_mark_node)
7241 return error_mark_node;
7242 return make_pointer_declarator (type, e);
7247 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7248 if (e == error_mark_node)
7249 return error_mark_node;
7250 return make_reference_declarator (type, e);
7255 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7256 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl);
7257 if (e1 == error_mark_node || e2 == error_mark_node)
7258 return error_mark_node;
7260 return build_nt (ARRAY_REF, e1, e2);
7265 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7266 tree e2 = (tsubst_call_declarator_parms
7267 (CALL_DECLARATOR_PARMS (t), args, complain, in_decl));
7268 tree e3 = tsubst (CALL_DECLARATOR_EXCEPTION_SPEC (t), args,
7271 if (e1 == error_mark_node || e2 == error_mark_node
7272 || e3 == error_mark_node)
7273 return error_mark_node;
7275 return make_call_declarator (e1, e2, CALL_DECLARATOR_QUALS (t), e3);
7280 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7281 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7282 if (e1 == error_mark_node || e2 == error_mark_node)
7283 return error_mark_node;
7285 return build_nt (TREE_CODE (t), e1, e2);
7292 type = finish_typeof (tsubst_expr (TYPE_FIELDS (t), args, complain,
7294 return cp_build_qualified_type_real (type,
7296 | cp_type_quals (type),
7301 sorry ("use of `%s' in template",
7302 tree_code_name [(int) TREE_CODE (t)]);
7303 return error_mark_node;
7307 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7308 type of the expression on the left-hand side of the "." or "->"
7312 tsubst_baselink (tree baselink, tree object_type,
7313 tree args, tsubst_flags_t complain, tree in_decl)
7316 tree qualifying_scope;
7318 tree template_args = 0;
7319 bool template_id_p = false;
7321 /* A baselink indicates a function from a base class. The
7322 BASELINK_ACCESS_BINFO and BASELINK_BINFO are going to have
7323 non-dependent types; otherwise, the lookup could not have
7324 succeeded. However, they may indicate bases of the template
7325 class, rather than the instantiated class.
7327 In addition, lookups that were not ambiguous before may be
7328 ambiguous now. Therefore, we perform the lookup again. */
7329 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7330 fns = BASELINK_FUNCTIONS (baselink);
7331 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7333 template_id_p = true;
7334 template_args = TREE_OPERAND (fns, 1);
7335 fns = TREE_OPERAND (fns, 0);
7337 template_args = tsubst_template_args (template_args, args,
7340 name = DECL_NAME (get_first_fn (fns));
7341 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7342 if (BASELINK_P (baselink) && template_id_p)
7343 BASELINK_FUNCTIONS (baselink)
7344 = build_nt (TEMPLATE_ID_EXPR,
7345 BASELINK_FUNCTIONS (baselink),
7348 object_type = current_class_type;
7349 return adjust_result_of_qualified_name_lookup (baselink,
7354 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7355 true if the qualified-id will be a postfix-expression in-and-of
7356 itself; false if more of the postfix-expression follows the
7357 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7361 tsubst_qualified_id (tree qualified_id, tree args,
7362 tsubst_flags_t complain, tree in_decl,
7363 bool done, bool address_p)
7371 my_friendly_assert (TREE_CODE (qualified_id) == SCOPE_REF, 20030706);
7373 /* Figure out what name to look up. */
7374 name = TREE_OPERAND (qualified_id, 1);
7375 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7378 template_args = TREE_OPERAND (name, 1);
7380 template_args = tsubst_template_args (template_args, args,
7382 name = TREE_OPERAND (name, 0);
7386 is_template = false;
7387 template_args = NULL_TREE;
7390 /* Substitute into the qualifying scope. When there are no ARGS, we
7391 are just trying to simplify a non-dependent expression. In that
7392 case the qualifying scope may be dependent, and, in any case,
7393 substituting will not help. */
7394 scope = TREE_OPERAND (qualified_id, 0);
7397 scope = tsubst (scope, args, complain, in_decl);
7398 expr = tsubst_copy (name, args, complain, in_decl);
7403 if (dependent_type_p (scope))
7404 return build_nt (SCOPE_REF, scope, expr);
7406 if (!BASELINK_P (name) && !DECL_P (expr))
7408 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7409 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7410 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7412 if (complain & tf_error)
7414 error ("dependent-name `%E' is parsed as a non-type, but "
7415 "instantiation yields a type", qualified_id);
7416 inform ("say `typename %E' if a type is meant", qualified_id);
7418 return error_mark_node;
7423 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7426 /* Remember that there was a reference to this entity. */
7431 expr = lookup_template_function (expr, template_args);
7433 if (expr == error_mark_node && complain & tf_error)
7434 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1));
7435 else if (TYPE_P (scope))
7437 expr = (adjust_result_of_qualified_name_lookup
7438 (expr, scope, current_class_type));
7439 expr = finish_qualified_id_expr (scope, expr, done, address_p);
7445 /* Like tsubst, but deals with expressions. This function just replaces
7446 template parms; to finish processing the resultant expression, use
7450 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7452 enum tree_code code;
7455 if (t == NULL_TREE || t == error_mark_node)
7458 code = TREE_CODE (t);
7463 r = retrieve_local_specialization (t);
7464 my_friendly_assert (r != NULL, 20020903);
7473 if (DECL_TEMPLATE_PARM_P (t))
7474 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
7475 /* There is no need to substitute into namespace-scope
7477 if (DECL_NAMESPACE_SCOPE_P (t))
7479 /* If ARGS is NULL, then T is known to be non-dependent. */
7480 if (args == NULL_TREE)
7481 return decl_constant_value (t);
7483 /* Unfortunately, we cannot just call lookup_name here.
7486 template <int I> int f() {
7488 struct S { void g() { E e = a; } };
7491 When we instantiate f<7>::S::g(), say, lookup_name is not
7492 clever enough to find f<7>::a. */
7494 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
7495 /*entering_scope=*/0);
7497 for (v = TYPE_VALUES (enum_type);
7500 if (TREE_PURPOSE (v) == DECL_NAME (t))
7501 return TREE_VALUE (v);
7503 /* We didn't find the name. That should never happen; if
7504 name-lookup found it during preliminary parsing, we
7505 should find it again here during instantiation. */
7511 if (DECL_CONTEXT (t))
7515 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
7516 /*entering_scope=*/1);
7517 if (ctx != DECL_CONTEXT (t))
7519 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
7522 if (complain & tf_error)
7523 error ("using invalid field `%D'", t);
7524 return error_mark_node;
7533 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
7534 || local_variable_p (t))
7535 t = tsubst (t, args, complain, in_decl);
7540 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
7543 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7544 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
7545 args, complain, in_decl);
7546 else if (is_member_template (t))
7547 return tsubst (t, args, complain, in_decl);
7548 else if (DECL_CLASS_SCOPE_P (t)
7549 && uses_template_parms (DECL_CONTEXT (t)))
7551 /* Template template argument like the following example need
7554 template <template <class> class TT> struct C {};
7555 template <class T> struct D {
7556 template <class U> struct E {};
7561 We are processing the template argument `E' in #1 for
7562 the template instantiation #2. Originally, `E' is a
7563 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
7564 have to substitute this with one having context `D<int>'. */
7566 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
7567 return lookup_field (context, DECL_NAME(t), 0, false);
7570 /* Ordinary template template argument. */
7574 case REINTERPRET_CAST_EXPR:
7575 case CONST_CAST_EXPR:
7576 case STATIC_CAST_EXPR:
7577 case DYNAMIC_CAST_EXPR:
7580 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7581 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7585 case TRUTH_NOT_EXPR:
7588 case CONVERT_EXPR: /* Unary + */
7597 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7598 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7605 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
7606 name = TREE_OPERAND (t, 1);
7607 if (TREE_CODE (name) == BIT_NOT_EXPR)
7609 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7611 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7613 else if (TREE_CODE (name) == SCOPE_REF
7614 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
7616 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
7618 name = TREE_OPERAND (name, 1);
7619 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7621 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7622 name = build_nt (SCOPE_REF, base, name);
7624 else if (TREE_CODE (name) == BASELINK)
7625 name = tsubst_baselink (name,
7626 non_reference (TREE_TYPE (object)),
7630 name = tsubst_copy (name, args, complain, in_decl);
7631 return build_nt (COMPONENT_REF, object, name);
7637 case TRUNC_DIV_EXPR:
7639 case FLOOR_DIV_EXPR:
7640 case ROUND_DIV_EXPR:
7641 case EXACT_DIV_EXPR:
7645 case TRUNC_MOD_EXPR:
7646 case FLOOR_MOD_EXPR:
7647 case TRUTH_ANDIF_EXPR:
7648 case TRUTH_ORIF_EXPR:
7649 case TRUTH_AND_EXPR:
7668 case PREDECREMENT_EXPR:
7669 case PREINCREMENT_EXPR:
7670 case POSTDECREMENT_EXPR:
7671 case POSTINCREMENT_EXPR:
7673 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7674 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7677 return build_nt (code,
7678 tsubst_copy (TREE_OPERAND (t, 0), args,
7680 tsubst_copy (TREE_OPERAND (t, 1), args, complain,
7685 /* This processing should really occur in tsubst_expr. However,
7686 tsubst_expr does not recurse into expressions, since it
7687 assumes that there aren't any statements inside them. So, we
7688 need to expand the STMT_EXPR here. */
7689 if (!processing_template_decl)
7691 tree stmt_expr = begin_stmt_expr ();
7693 tsubst_expr (STMT_EXPR_STMT (t), args,
7694 complain | tf_stmt_expr_cmpd, in_decl);
7695 return finish_stmt_expr (stmt_expr, false);
7702 case PSEUDO_DTOR_EXPR:
7705 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7706 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7707 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7714 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7715 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7716 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7717 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
7724 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7725 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7726 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
7727 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
7731 case TEMPLATE_ID_EXPR:
7733 /* Substituted template arguments */
7734 tree fn = TREE_OPERAND (t, 0);
7735 tree targs = TREE_OPERAND (t, 1);
7737 fn = tsubst_copy (fn, args, complain, in_decl);
7739 targs = tsubst_template_args (targs, args, complain, in_decl);
7741 return lookup_template_function (fn, targs);
7746 tree purpose, value, chain;
7748 if (t == void_list_node)
7751 purpose = TREE_PURPOSE (t);
7753 purpose = tsubst_copy (purpose, args, complain, in_decl);
7754 value = TREE_VALUE (t);
7756 value = tsubst_copy (value, args, complain, in_decl);
7757 chain = TREE_CHAIN (t);
7758 if (chain && chain != void_type_node)
7759 chain = tsubst_copy (chain, args, complain, in_decl);
7760 if (purpose == TREE_PURPOSE (t)
7761 && value == TREE_VALUE (t)
7762 && chain == TREE_CHAIN (t))
7764 return tree_cons (purpose, value, chain);
7771 case TEMPLATE_TYPE_PARM:
7772 case TEMPLATE_TEMPLATE_PARM:
7773 case BOUND_TEMPLATE_TEMPLATE_PARM:
7774 case TEMPLATE_PARM_INDEX:
7776 case REFERENCE_TYPE:
7782 case UNBOUND_CLASS_TEMPLATE:
7785 return tsubst (t, args, complain, in_decl);
7787 case IDENTIFIER_NODE:
7788 if (IDENTIFIER_TYPENAME_P (t))
7790 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7791 return mangle_conv_op_name_for_type (new_type);
7798 r = build_constructor
7799 (tsubst (TREE_TYPE (t), args, complain, in_decl),
7800 tsubst_copy (CONSTRUCTOR_ELTS (t), args, complain, in_decl));
7801 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
7806 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
7808 tsubst (TREE_TYPE (t), args, complain, in_decl));
7811 mark_used (TREE_OPERAND (t, 1));
7819 /* Like tsubst_copy for expressions, etc. but also does semantic
7823 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7826 tsubst_flags_t stmt_expr
7827 = complain & (tf_stmt_expr_cmpd | tf_stmt_expr_body);
7829 complain ^= stmt_expr;
7830 if (t == NULL_TREE || t == error_mark_node)
7833 if (!STATEMENT_CODE_P (TREE_CODE (t)))
7834 return tsubst_copy_and_build (t, args, complain, in_decl,
7835 /*function_p=*/false);
7837 switch (TREE_CODE (t))
7839 case CTOR_INITIALIZER:
7841 finish_mem_initializers (tsubst_initializer_list
7842 (TREE_OPERAND (t, 0), args));
7847 finish_return_stmt (tsubst_expr (RETURN_STMT_EXPR (t),
7848 args, complain, in_decl));
7857 r = tsubst_expr (EXPR_STMT_EXPR (t), args, complain, in_decl);
7858 if (stmt_expr & tf_stmt_expr_body && !TREE_CHAIN (t))
7859 finish_stmt_expr_expr (r);
7861 finish_expr_stmt (r);
7867 do_using_directive (tsubst_expr (USING_STMT_NAMESPACE (t),
7868 args, complain, in_decl));
7877 decl = DECL_STMT_DECL (t);
7878 if (TREE_CODE (decl) == LABEL_DECL)
7879 finish_label_decl (DECL_NAME (decl));
7880 else if (TREE_CODE (decl) == USING_DECL)
7882 tree scope = DECL_INITIAL (decl);
7883 tree name = DECL_NAME (decl);
7886 scope = tsubst_expr (scope, args, complain, in_decl);
7887 decl = lookup_qualified_name (scope, name,
7888 /*is_type_p=*/false,
7889 /*complain=*/false);
7890 if (decl == error_mark_node)
7891 qualified_name_lookup_error (scope, name);
7893 do_local_using_decl (decl, scope, name);
7897 init = DECL_INITIAL (decl);
7898 decl = tsubst (decl, args, complain, in_decl);
7899 if (decl != error_mark_node)
7902 DECL_INITIAL (decl) = error_mark_node;
7903 /* By marking the declaration as instantiated, we avoid
7904 trying to instantiate it. Since instantiate_decl can't
7905 handle local variables, and since we've already done
7906 all that needs to be done, that's the right thing to
7908 if (TREE_CODE (decl) == VAR_DECL)
7909 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
7910 if (TREE_CODE (decl) == VAR_DECL
7911 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
7912 /* Anonymous aggregates are a special case. */
7913 finish_anon_union (decl);
7916 maybe_push_decl (decl);
7917 if (TREE_CODE (decl) == VAR_DECL
7918 && DECL_PRETTY_FUNCTION_P (decl))
7920 /* For __PRETTY_FUNCTION__ we have to adjust the
7922 const char *const name
7923 = cxx_printable_name (current_function_decl, 2);
7924 init = cp_fname_init (name, &TREE_TYPE (decl));
7927 init = tsubst_expr (init, args, complain, in_decl);
7928 cp_finish_decl (decl, init, NULL_TREE, 0);
7933 /* A DECL_STMT can also be used as an expression, in the condition
7934 clause of an if/for/while construct. If we aren't followed by
7935 another statement, return our decl. */
7936 if (TREE_CHAIN (t) == NULL_TREE)
7945 stmt = begin_for_stmt ();
7946 tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl);
7947 finish_for_init_stmt (stmt);
7948 finish_for_cond (tsubst_expr (FOR_COND (t),
7949 args, complain, in_decl),
7951 tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
7952 finish_for_expr (tmp, stmt);
7953 tsubst_expr (FOR_BODY (t), args, complain, in_decl);
7954 finish_for_stmt (stmt);
7961 stmt = begin_while_stmt ();
7962 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t),
7963 args, complain, in_decl),
7965 tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
7966 finish_while_stmt (stmt);
7973 stmt = begin_do_stmt ();
7974 tsubst_expr (DO_BODY (t), args, complain, in_decl);
7975 finish_do_body (stmt);
7976 finish_do_stmt (tsubst_expr (DO_COND (t),
7977 args, complain, in_decl),
7985 stmt = begin_if_stmt ();
7986 finish_if_stmt_cond (tsubst_expr (IF_COND (t),
7987 args, complain, in_decl),
7990 if (tmp = THEN_CLAUSE (t), tmp)
7992 tsubst_expr (tmp, args, complain, in_decl);
7993 finish_then_clause (stmt);
7996 if (tmp = ELSE_CLAUSE (t), tmp)
7998 begin_else_clause ();
7999 tsubst_expr (tmp, args, complain, in_decl);
8000 finish_else_clause (stmt);
8010 if (COMPOUND_STMT_BODY_BLOCK (t))
8011 stmt = begin_function_body ();
8013 stmt = begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t));
8015 tsubst_expr (COMPOUND_BODY (t), args,
8016 complain | ((stmt_expr & tf_stmt_expr_cmpd) << 1),
8019 if (COMPOUND_STMT_BODY_BLOCK (t))
8020 finish_function_body (stmt);
8022 finish_compound_stmt (stmt);
8028 finish_break_stmt ();
8033 finish_continue_stmt ();
8041 stmt = begin_switch_stmt ();
8042 val = tsubst_expr (SWITCH_COND (t), args, complain, in_decl);
8043 finish_switch_cond (val, stmt);
8044 tsubst_expr (SWITCH_BODY (t), args, complain, in_decl);
8045 finish_switch_stmt (stmt);
8051 finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl),
8052 tsubst_expr (CASE_HIGH (t), args, complain,
8057 input_line = STMT_LINENO (t);
8058 finish_label_stmt (DECL_NAME (LABEL_STMT_LABEL (t)));
8062 input_filename = FILE_STMT_FILENAME (t);
8063 add_stmt (build_nt (FILE_STMT, FILE_STMT_FILENAME_NODE (t)));
8068 tmp = GOTO_DESTINATION (t);
8069 if (TREE_CODE (tmp) != LABEL_DECL)
8070 /* Computed goto's must be tsubst'd into. On the other hand,
8071 non-computed gotos must not be; the identifier in question
8072 will have no binding. */
8073 tmp = tsubst_expr (tmp, args, complain, in_decl);
8075 tmp = DECL_NAME (tmp);
8076 finish_goto_stmt (tmp);
8081 tmp = finish_asm_stmt
8083 tsubst_expr (ASM_STRING (t), args, complain, in_decl),
8084 tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl),
8085 tsubst_expr (ASM_INPUTS (t), args, complain, in_decl),
8086 tsubst_expr (ASM_CLOBBERS (t), args, complain, in_decl));
8087 ASM_INPUT_P (tmp) = ASM_INPUT_P (t);
8094 stmt = begin_try_block ();
8095 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
8096 finish_cleanup_try_block (stmt);
8097 finish_cleanup (tsubst_expr (TRY_HANDLERS (t), args,
8103 if (FN_TRY_BLOCK_P (t))
8104 stmt = begin_function_try_block ();
8106 stmt = begin_try_block ();
8108 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
8110 if (FN_TRY_BLOCK_P (t))
8111 finish_function_try_block (stmt);
8113 finish_try_block (stmt);
8115 tsubst_expr (TRY_HANDLERS (t), args, complain, in_decl);
8116 if (FN_TRY_BLOCK_P (t))
8117 finish_function_handler_sequence (stmt);
8119 finish_handler_sequence (stmt);
8128 stmt = begin_handler ();
8129 if (HANDLER_PARMS (t))
8131 decl = DECL_STMT_DECL (HANDLER_PARMS (t));
8132 decl = tsubst (decl, args, complain, in_decl);
8133 /* Prevent instantiate_decl from trying to instantiate
8134 this variable. We've already done all that needs to be
8136 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8140 finish_handler_parms (decl, stmt);
8141 tsubst_expr (HANDLER_BODY (t), args, complain, in_decl);
8142 finish_handler (stmt);
8148 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8155 return tsubst_expr (TREE_CHAIN (t), args, complain | stmt_expr, in_decl);
8158 /* T is a postfix-expression that is not being used in a function
8159 call. Return the substituted version of T. */
8162 tsubst_non_call_postfix_expression (tree t, tree args,
8163 tsubst_flags_t complain,
8166 if (TREE_CODE (t) == SCOPE_REF)
8167 t = tsubst_qualified_id (t, args, complain, in_decl,
8168 /*done=*/false, /*address_p=*/false);
8170 t = tsubst_copy_and_build (t, args, complain, in_decl,
8171 /*function_p=*/false);
8176 /* Like tsubst but deals with expressions and performs semantic
8177 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8180 tsubst_copy_and_build (tree t,
8182 tsubst_flags_t complain,
8186 #define RECUR(NODE) \
8187 tsubst_copy_and_build (NODE, args, complain, in_decl, /*function_p=*/false)
8191 if (t == NULL_TREE || t == error_mark_node)
8194 switch (TREE_CODE (t))
8199 case IDENTIFIER_NODE:
8203 tree qualifying_class;
8204 bool non_integral_constant_expression_p;
8205 const char *error_msg;
8207 if (IDENTIFIER_TYPENAME_P (t))
8209 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8210 t = mangle_conv_op_name_for_type (new_type);
8213 /* Look up the name. */
8214 decl = lookup_name (t, 0);
8216 /* By convention, expressions use ERROR_MARK_NODE to indicate
8217 failure, not NULL_TREE. */
8218 if (decl == NULL_TREE)
8219 decl = error_mark_node;
8221 decl = finish_id_expression (t, decl, NULL_TREE,
8224 /*integral_constant_expression_p=*/false,
8225 /*allow_non_integral_constant_expression_p=*/false,
8226 &non_integral_constant_expression_p,
8230 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8231 decl = unqualified_name_lookup_error (decl);
8235 case TEMPLATE_ID_EXPR:
8238 tree template = RECUR (TREE_OPERAND (t, 0));
8239 tree targs = TREE_OPERAND (t, 1);
8242 targs = tsubst_template_args (targs, args, complain, in_decl);
8244 if (TREE_CODE (template) == COMPONENT_REF)
8246 object = TREE_OPERAND (template, 0);
8247 template = TREE_OPERAND (template, 1);
8251 template = lookup_template_function (template, targs);
8254 return build (COMPONENT_REF, TREE_TYPE (template),
8261 return build_x_indirect_ref (RECUR (TREE_OPERAND (t, 0)), "unary *");
8265 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8266 RECUR (TREE_OPERAND (t, 0)));
8269 return build_functional_cast
8270 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8271 RECUR (TREE_OPERAND (t, 0)));
8273 case REINTERPRET_CAST_EXPR:
8274 return build_reinterpret_cast
8275 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8276 RECUR (TREE_OPERAND (t, 0)));
8278 case CONST_CAST_EXPR:
8279 return build_const_cast
8280 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8281 RECUR (TREE_OPERAND (t, 0)));
8283 case DYNAMIC_CAST_EXPR:
8284 return build_dynamic_cast
8285 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8286 RECUR (TREE_OPERAND (t, 0)));
8288 case STATIC_CAST_EXPR:
8289 return build_static_cast
8290 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8291 RECUR (TREE_OPERAND (t, 0)));
8293 case POSTDECREMENT_EXPR:
8294 case POSTINCREMENT_EXPR:
8295 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8296 args, complain, in_decl);
8297 return build_x_unary_op (TREE_CODE (t), op1);
8299 case PREDECREMENT_EXPR:
8300 case PREINCREMENT_EXPR:
8304 case TRUTH_NOT_EXPR:
8305 case CONVERT_EXPR: /* Unary + */
8308 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
8311 op1 = TREE_OPERAND (t, 0);
8312 if (TREE_CODE (op1) == SCOPE_REF)
8313 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
8314 /*done=*/true, /*address_p=*/true);
8316 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
8318 if (TREE_CODE (op1) == LABEL_DECL)
8319 return finish_label_address_expr (DECL_NAME (op1));
8320 return build_x_unary_op (ADDR_EXPR, op1);
8325 case TRUNC_DIV_EXPR:
8327 case FLOOR_DIV_EXPR:
8328 case ROUND_DIV_EXPR:
8329 case EXACT_DIV_EXPR:
8333 case TRUNC_MOD_EXPR:
8334 case FLOOR_MOD_EXPR:
8335 case TRUTH_ANDIF_EXPR:
8336 case TRUTH_ORIF_EXPR:
8337 case TRUTH_AND_EXPR:
8353 return build_x_binary_op
8355 RECUR (TREE_OPERAND (t, 0)),
8356 RECUR (TREE_OPERAND (t, 1)),
8357 /*overloaded_p=*/NULL);
8360 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
8361 /*address_p=*/false);
8364 if (tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)
8367 return build_nt (ARRAY_REF, NULL_TREE, RECUR (TREE_OPERAND (t, 1)));
8369 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8370 args, complain, in_decl);
8371 /* Remember that there was a reference to this entity. */
8374 return grok_array_decl (op1, RECUR (TREE_OPERAND (t, 1)));
8378 op1 = TREE_OPERAND (t, 0);
8381 /* When there are no ARGS, we are trying to evaluate a
8382 non-dependent expression from the parser. Trying to do
8383 the substitutions may not work. */
8385 op1 = TREE_TYPE (op1);
8394 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
8396 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
8399 return build_x_modify_expr
8400 (RECUR (TREE_OPERAND (t, 0)),
8401 TREE_CODE (TREE_OPERAND (t, 1)),
8402 RECUR (TREE_OPERAND (t, 2)));
8405 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8406 args, complain, in_decl);
8407 /* Remember that there was a reference to this entity. */
8410 return build_x_arrow (op1);
8414 (RECUR (TREE_OPERAND (t, 0)),
8415 RECUR (TREE_OPERAND (t, 1)),
8416 RECUR (TREE_OPERAND (t, 2)),
8417 NEW_EXPR_USE_GLOBAL (t));
8420 return delete_sanity
8421 (RECUR (TREE_OPERAND (t, 0)),
8422 RECUR (TREE_OPERAND (t, 1)),
8423 DELETE_EXPR_USE_VEC (t),
8424 DELETE_EXPR_USE_GLOBAL (t));
8427 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
8428 RECUR (TREE_OPERAND (t, 1)));
8437 function = TREE_OPERAND (t, 0);
8438 /* When we parsed the expression, we determined whether or
8439 not Koenig lookup should be performed. */
8440 koenig_p = KOENIG_LOOKUP_P (t);
8441 if (TREE_CODE (function) == SCOPE_REF)
8444 function = tsubst_qualified_id (function, args, complain, in_decl,
8446 /*address_p=*/false);
8450 qualified_p = (TREE_CODE (function) == COMPONENT_REF
8451 && (TREE_CODE (TREE_OPERAND (function, 1))
8453 function = tsubst_copy_and_build (function, args, complain,
8456 if (BASELINK_P (function))
8460 call_args = RECUR (TREE_OPERAND (t, 1));
8462 /* We do not perform argument-dependent lookup if normal
8463 lookup finds a non-function, in accordance with the
8464 expected resolution of DR 218. */
8466 && ((is_overloaded_fn (function)
8467 /* If lookup found a member function, the Koenig lookup is
8468 not appropriate, even if an unqualified-name was used
8469 to denote the function. */
8470 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
8471 || TREE_CODE (function) == IDENTIFIER_NODE))
8472 function = perform_koenig_lookup (function, call_args);
8474 if (TREE_CODE (function) == IDENTIFIER_NODE)
8476 unqualified_name_lookup_error (function);
8477 return error_mark_node;
8480 /* Remember that there was a reference to this entity. */
8481 if (DECL_P (function))
8482 mark_used (function);
8484 function = convert_from_reference (function);
8486 if (TREE_CODE (function) == OFFSET_REF)
8487 return build_offset_ref_call_from_tree (function, call_args);
8488 if (TREE_CODE (function) == COMPONENT_REF)
8490 if (!BASELINK_P (TREE_OPERAND (function, 1)))
8491 return finish_call_expr (function, call_args,
8492 /*disallow_virtual=*/false,
8493 /*koenig_p=*/false);
8495 return (build_new_method_call
8496 (TREE_OPERAND (function, 0),
8497 TREE_OPERAND (function, 1),
8498 call_args, NULL_TREE,
8499 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL));
8501 return finish_call_expr (function, call_args,
8502 /*disallow_virtual=*/qualified_p,
8507 return build_x_conditional_expr
8508 (RECUR (TREE_OPERAND (t, 0)),
8509 RECUR (TREE_OPERAND (t, 1)),
8510 RECUR (TREE_OPERAND (t, 2)));
8512 case PSEUDO_DTOR_EXPR:
8513 return finish_pseudo_destructor_expr
8514 (RECUR (TREE_OPERAND (t, 0)),
8515 RECUR (TREE_OPERAND (t, 1)),
8516 RECUR (TREE_OPERAND (t, 2)));
8520 tree purpose, value, chain;
8522 if (t == void_list_node)
8525 purpose = TREE_PURPOSE (t);
8527 purpose = RECUR (purpose);
8528 value = TREE_VALUE (t);
8530 value = RECUR (value);
8531 chain = TREE_CHAIN (t);
8532 if (chain && chain != void_type_node)
8533 chain = RECUR (chain);
8534 if (purpose == TREE_PURPOSE (t)
8535 && value == TREE_VALUE (t)
8536 && chain == TREE_CHAIN (t))
8538 return tree_cons (purpose, value, chain);
8546 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8547 args, complain, in_decl);
8548 /* Remember that there was a reference to this entity. */
8549 if (DECL_P (object))
8552 member = TREE_OPERAND (t, 1);
8553 if (BASELINK_P (member))
8554 member = tsubst_baselink (member,
8555 non_reference (TREE_TYPE (object)),
8556 args, complain, in_decl);
8558 member = tsubst_copy (member, args, complain, in_decl);
8560 if (member == error_mark_node)
8561 return error_mark_node;
8562 else if (!CLASS_TYPE_P (TREE_TYPE (object)))
8564 if (TREE_CODE (member) == BIT_NOT_EXPR)
8565 return finish_pseudo_destructor_expr (object,
8567 TREE_TYPE (object));
8568 else if (TREE_CODE (member) == SCOPE_REF
8569 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
8570 return finish_pseudo_destructor_expr (object,
8572 TREE_TYPE (object));
8574 else if (TREE_CODE (member) == SCOPE_REF
8575 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
8580 /* Lookup the template functions now that we know what the
8582 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
8583 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
8584 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
8585 /*is_type_p=*/false,
8586 /*complain=*/false);
8587 if (BASELINK_P (member))
8589 BASELINK_FUNCTIONS (member)
8590 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
8592 member = (adjust_result_of_qualified_name_lookup
8593 (member, BINFO_TYPE (BASELINK_BINFO (member)),
8594 TREE_TYPE (object)));
8598 qualified_name_lookup_error (TREE_TYPE (object), tmpl);
8599 return error_mark_node;
8602 else if (TREE_CODE (member) == SCOPE_REF
8603 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
8604 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
8606 if (complain & tf_error)
8608 if (TYPE_P (TREE_OPERAND (member, 0)))
8609 error ("`%T' is not a class or namespace",
8610 TREE_OPERAND (member, 0));
8612 error ("`%D' is not a class or namespace",
8613 TREE_OPERAND (member, 0));
8615 return error_mark_node;
8617 else if (TREE_CODE (member) == FIELD_DECL)
8618 return finish_non_static_data_member (member, object, NULL_TREE);
8620 return finish_class_member_access_expr (object, member);
8625 (RECUR (TREE_OPERAND (t, 0)));
8631 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8634 /* digest_init will do the wrong thing if we let it. */
8635 if (type && TYPE_PTRMEMFUNC_P (type))
8639 /* We do not want to process the purpose of aggregate
8640 initializers as they are identifier nodes which will be
8641 looked up by digest_init. */
8642 purpose_p = !(type && IS_AGGR_TYPE (type));
8643 for (elts = CONSTRUCTOR_ELTS (t);
8645 elts = TREE_CHAIN (elts))
8647 tree purpose = TREE_PURPOSE (elts);
8648 tree value = TREE_VALUE (elts);
8650 if (purpose && purpose_p)
8651 purpose = RECUR (purpose);
8652 value = RECUR (value);
8653 r = tree_cons (purpose, value, r);
8656 r = build_constructor (NULL_TREE, nreverse (r));
8657 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
8660 return digest_init (type, r, 0);
8666 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
8667 if (TYPE_P (operand_0))
8668 return get_typeid (operand_0);
8669 return build_typeid (operand_0);
8673 return convert_from_reference (tsubst_copy (t, args, complain, in_decl));
8677 t = tsubst_copy (t, args, complain, in_decl);
8678 return convert_from_reference (t);
8681 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
8682 tsubst_copy (TREE_TYPE (t), args, complain,
8686 t = tsubst_copy (t, args, complain, in_decl);
8687 /* As in finish_id_expression, we resolve enumeration constants
8688 to their underlying values. */
8689 if (TREE_CODE (t) == CONST_DECL)
8690 return DECL_INITIAL (t);
8694 return tsubst_copy (t, args, complain, in_decl);
8700 /* Verify that the instantiated ARGS are valid. For type arguments,
8701 make sure that the type's linkage is ok. For non-type arguments,
8702 make sure they are constants if they are integral or enumerations.
8703 Emit an error under control of COMPLAIN, and return TRUE on error. */
8706 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
8708 int ix, len = DECL_NTPARMS (tmpl);
8709 bool result = false;
8711 for (ix = 0; ix != len; ix++)
8713 tree t = TREE_VEC_ELT (args, ix);
8717 /* [basic.link]: A name with no linkage (notably, the name
8718 of a class or enumeration declared in a local scope)
8719 shall not be used to declare an entity with linkage.
8720 This implies that names with no linkage cannot be used as
8721 template arguments. */
8722 tree nt = no_linkage_check (t);
8726 if (!(complain & tf_error))
8728 else if (TYPE_ANONYMOUS_P (nt))
8729 error ("`%T' uses anonymous type", t);
8731 error ("`%T' uses local type `%T'", t, nt);
8734 /* In order to avoid all sorts of complications, we do not
8735 allow variably-modified types as template arguments. */
8736 else if (variably_modified_type_p (t))
8738 if (complain & tf_error)
8739 error ("`%T' is a variably modified type", t);
8743 /* A non-type argument of integral or enumerated type must be a
8745 else if (TREE_TYPE (t)
8746 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
8747 && !TREE_CONSTANT (t))
8749 if (complain & tf_error)
8750 error ("integral expression `%E' is not constant", t);
8754 if (result && complain & tf_error)
8755 error (" trying to instantiate `%D'", tmpl);
8759 /* Instantiate the indicated variable or function template TMPL with
8760 the template arguments in TARG_PTR. */
8763 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
8769 if (tmpl == error_mark_node)
8770 return error_mark_node;
8772 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283);
8774 /* If this function is a clone, handle it specially. */
8775 if (DECL_CLONED_FUNCTION_P (tmpl))
8780 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
8782 if (spec == error_mark_node)
8783 return error_mark_node;
8785 /* Look for the clone. */
8786 for (clone = TREE_CHAIN (spec);
8787 clone && DECL_CLONED_FUNCTION_P (clone);
8788 clone = TREE_CHAIN (clone))
8789 if (DECL_NAME (clone) == DECL_NAME (tmpl))
8791 /* We should always have found the clone by now. */
8796 /* Check to see if we already have this specialization. */
8797 spec = retrieve_specialization (tmpl, targ_ptr);
8798 if (spec != NULL_TREE)
8801 gen_tmpl = most_general_template (tmpl);
8802 if (tmpl != gen_tmpl)
8804 /* The TMPL is a partial instantiation. To get a full set of
8805 arguments we must add the arguments used to perform the
8806 partial instantiation. */
8807 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
8810 /* Check to see if we already have this specialization. */
8811 spec = retrieve_specialization (gen_tmpl, targ_ptr);
8812 if (spec != NULL_TREE)
8816 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
8818 return error_mark_node;
8820 /* We are building a FUNCTION_DECL, during which the access of its
8821 parameters and return types have to be checked. However this
8822 FUNCTION_DECL which is the desired context for access checking
8823 is not built yet. We solve this chicken-and-egg problem by
8824 deferring all checks until we have the FUNCTION_DECL. */
8825 push_deferring_access_checks (dk_deferred);
8827 /* Substitute template parameters. */
8828 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
8829 targ_ptr, complain, gen_tmpl);
8831 /* Now we know the specialization, compute access previously
8833 push_access_scope (fndecl);
8834 perform_deferred_access_checks ();
8835 pop_access_scope (fndecl);
8836 pop_deferring_access_checks ();
8838 /* The DECL_TI_TEMPLATE should always be the immediate parent
8839 template, not the most general template. */
8840 DECL_TI_TEMPLATE (fndecl) = tmpl;
8842 /* If we've just instantiated the main entry point for a function,
8843 instantiate all the alternate entry points as well. We do this
8844 by cloning the instantiation of the main entry point, not by
8845 instantiating the template clones. */
8846 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
8847 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
8852 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
8853 arguments that are being used when calling it. TARGS is a vector
8854 into which the deduced template arguments are placed.
8856 Return zero for success, 2 for an incomplete match that doesn't resolve
8857 all the types, and 1 for complete failure. An error message will be
8858 printed only for an incomplete match.
8860 If FN is a conversion operator, or we are trying to produce a specific
8861 specialization, RETURN_TYPE is the return type desired.
8863 The EXPLICIT_TARGS are explicit template arguments provided via a
8866 The parameter STRICT is one of:
8869 We are deducing arguments for a function call, as in
8873 We are deducing arguments for a conversion function, as in
8877 We are deducing arguments when doing an explicit instantiation
8878 as in [temp.explicit], when determining an explicit specialization
8879 as in [temp.expl.spec], or when taking the address of a function
8880 template, as in [temp.deduct.funcaddr].
8883 We are deducing arguments when calculating the partial
8884 ordering between specializations of function or class
8885 templates, as in [temp.func.order] and [temp.class.order].
8887 LEN is the number of parms to consider before returning success, or -1
8888 for all. This is used in partial ordering to avoid comparing parms for
8889 which no actual argument was passed, since they are not considered in
8890 overload resolution (and are explicitly excluded from consideration in
8891 partial ordering in [temp.func.order]/6). */
8894 fn_type_unification (tree fn,
8895 tree explicit_targs,
8899 unification_kind_t strict,
8906 my_friendly_assert (TREE_CODE (fn) == TEMPLATE_DECL, 0);
8908 fntype = TREE_TYPE (fn);
8913 The specified template arguments must match the template
8914 parameters in kind (i.e., type, nontype, template), and there
8915 must not be more arguments than there are parameters;
8916 otherwise type deduction fails.
8918 Nontype arguments must match the types of the corresponding
8919 nontype template parameters, or must be convertible to the
8920 types of the corresponding nontype parameters as specified in
8921 _temp.arg.nontype_, otherwise type deduction fails.
8923 All references in the function type of the function template
8924 to the corresponding template parameters are replaced by the
8925 specified template argument values. If a substitution in a
8926 template parameter or in the function type of the function
8927 template results in an invalid type, type deduction fails. */
8929 tree converted_args;
8932 if (explicit_targs == error_mark_node)
8936 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
8937 explicit_targs, NULL_TREE, tf_none,
8938 /*require_all_arguments=*/0));
8939 if (converted_args == error_mark_node)
8942 /* Substitute the explicit args into the function type. This is
8943 necessary so that, for instance, explicitly declared function
8944 arguments can match null pointed constants. If we were given
8945 an incomplete set of explicit args, we must not do semantic
8946 processing during substitution as we could create partial
8948 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
8949 processing_template_decl += incomplete;
8950 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
8951 processing_template_decl -= incomplete;
8953 if (fntype == error_mark_node)
8956 /* Place the explicitly specified arguments in TARGS. */
8957 for (i = NUM_TMPL_ARGS (converted_args); i--;)
8958 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
8961 parms = TYPE_ARG_TYPES (fntype);
8962 /* Never do unification on the 'this' parameter. */
8963 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
8964 parms = TREE_CHAIN (parms);
8968 /* We've been given a return type to match, prepend it. */
8969 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
8970 args = tree_cons (NULL_TREE, return_type, args);
8975 /* We allow incomplete unification without an error message here
8976 because the standard doesn't seem to explicitly prohibit it. Our
8977 callers must be ready to deal with unification failures in any
8979 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
8980 targs, parms, args, /*subr=*/0,
8981 strict, /*allow_incomplete*/1, len);
8984 /* All is well so far. Now, check:
8988 When all template arguments have been deduced, all uses of
8989 template parameters in nondeduced contexts are replaced with
8990 the corresponding deduced argument values. If the
8991 substitution results in an invalid type, as described above,
8992 type deduction fails. */
8993 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
9000 /* Adjust types before performing type deduction, as described in
9001 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
9002 sections are symmetric. PARM is the type of a function parameter
9003 or the return type of the conversion function. ARG is the type of
9004 the argument passed to the call, or the type of the value
9005 initialized with the result of the conversion function. */
9008 maybe_adjust_types_for_deduction (unification_kind_t strict,
9021 /* Swap PARM and ARG throughout the remainder of this
9022 function; the handling is precisely symmetric since PARM
9023 will initialize ARG rather than vice versa. */
9031 /* There is nothing to do in this case. */
9035 /* DR 214. [temp.func.order] is underspecified, and leads to no
9036 ordering between things like `T *' and `T const &' for `U *'.
9037 The former has T=U and the latter T=U*. The former looks more
9038 specialized and John Spicer considers it well-formed (the EDG
9039 compiler accepts it).
9041 John also confirms that deduction should proceed as in a function
9042 call. Which implies the usual ARG and PARM conversions as DEDUCE_CALL.
9043 However, in ordering, ARG can have REFERENCE_TYPE, but no argument
9044 to an actual call can have such a type.
9046 If both ARG and PARM are REFERENCE_TYPE, we change neither.
9047 If only ARG is a REFERENCE_TYPE, we look through that and then
9048 proceed as with DEDUCE_CALL (which could further convert it). */
9049 if (TREE_CODE (*arg) == REFERENCE_TYPE)
9051 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9053 *arg = TREE_TYPE (*arg);
9060 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9062 /* [temp.deduct.call]
9064 If P is not a reference type:
9066 --If A is an array type, the pointer type produced by the
9067 array-to-pointer standard conversion (_conv.array_) is
9068 used in place of A for type deduction; otherwise,
9070 --If A is a function type, the pointer type produced by
9071 the function-to-pointer standard conversion
9072 (_conv.func_) is used in place of A for type deduction;
9075 --If A is a cv-qualified type, the top level
9076 cv-qualifiers of A's type are ignored for type
9078 if (TREE_CODE (*arg) == ARRAY_TYPE)
9079 *arg = build_pointer_type (TREE_TYPE (*arg));
9080 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9081 *arg = build_pointer_type (*arg);
9083 *arg = TYPE_MAIN_VARIANT (*arg);
9086 /* [temp.deduct.call]
9088 If P is a cv-qualified type, the top level cv-qualifiers
9089 of P's type are ignored for type deduction. If P is a
9090 reference type, the type referred to by P is used for
9092 *parm = TYPE_MAIN_VARIANT (*parm);
9093 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9095 *parm = TREE_TYPE (*parm);
9096 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9099 /* DR 322. For conversion deduction, remove a reference type on parm
9100 too (which has been swapped into ARG). */
9101 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9102 *arg = TREE_TYPE (*arg);
9107 /* Most parms like fn_type_unification.
9109 If SUBR is 1, we're being called recursively (to unify the
9110 arguments of a function or method parameter of a function
9114 type_unification_real (tree tparms,
9119 unification_kind_t strict,
9120 int allow_incomplete,
9125 int ntparms = TREE_VEC_LENGTH (tparms);
9127 int saw_undeduced = 0;
9131 my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289);
9132 my_friendly_assert (xparms == NULL_TREE
9133 || TREE_CODE (xparms) == TREE_LIST, 290);
9134 my_friendly_assert (!xargs || TREE_CODE (xargs) == TREE_LIST, 291);
9135 my_friendly_assert (ntparms > 0, 292);
9140 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9141 | UNIFY_ALLOW_DERIVED);
9145 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9149 sub_strict = UNIFY_ALLOW_NONE;
9153 sub_strict = UNIFY_ALLOW_NONE;
9169 && parms != void_list_node
9171 && args != void_list_node)
9173 parm = TREE_VALUE (parms);
9174 parms = TREE_CHAIN (parms);
9175 arg = TREE_VALUE (args);
9176 args = TREE_CHAIN (args);
9178 if (arg == error_mark_node)
9180 if (arg == unknown_type_node)
9181 /* We can't deduce anything from this, but we might get all the
9182 template args from other function args. */
9185 /* Conversions will be performed on a function argument that
9186 corresponds with a function parameter that contains only
9187 non-deducible template parameters and explicitly specified
9188 template parameters. */
9189 if (!uses_template_parms (parm))
9194 type = TREE_TYPE (arg);
9198 if (same_type_p (parm, type))
9200 if (strict != DEDUCE_EXACT
9201 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg))
9209 my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293);
9210 if (type_unknown_p (arg))
9212 /* [temp.deduct.type] A template-argument can be deduced from
9213 a pointer to function or pointer to member function
9214 argument if the set of overloaded functions does not
9215 contain function templates and at most one of a set of
9216 overloaded functions provides a unique match. */
9218 if (resolve_overloaded_unification
9219 (tparms, targs, parm, arg, strict, sub_strict)
9224 arg = TREE_TYPE (arg);
9225 if (arg == error_mark_node)
9230 int arg_strict = sub_strict;
9233 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9235 if (unify (tparms, targs, parm, arg, arg_strict))
9239 /* Are we done with the interesting parms? */
9243 /* Fail if we've reached the end of the parm list, and more args
9244 are present, and the parm list isn't variadic. */
9245 if (args && args != void_list_node && parms == void_list_node)
9247 /* Fail if parms are left and they don't have default values. */
9249 && parms != void_list_node
9250 && TREE_PURPOSE (parms) == NULL_TREE)
9255 for (i = 0; i < ntparms; i++)
9256 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
9258 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
9260 /* If this is an undeduced nontype parameter that depends on
9261 a type parameter, try another pass; its type may have been
9262 deduced from a later argument than the one from which
9263 this parameter can be deduced. */
9264 if (TREE_CODE (tparm) == PARM_DECL
9265 && uses_template_parms (TREE_TYPE (tparm))
9266 && !saw_undeduced++)
9269 if (!allow_incomplete)
9270 error ("incomplete type unification");
9276 /* Subroutine of type_unification_real. Args are like the variables at the
9277 call site. ARG is an overloaded function (or template-id); we try
9278 deducing template args from each of the overloads, and if only one
9279 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
9282 resolve_overloaded_unification (tree tparms,
9286 unification_kind_t strict,
9289 tree tempargs = copy_node (targs);
9293 if (TREE_CODE (arg) == ADDR_EXPR)
9295 arg = TREE_OPERAND (arg, 0);
9301 if (TREE_CODE (arg) == COMPONENT_REF)
9302 /* Handle `&x' where `x' is some static or non-static member
9304 arg = TREE_OPERAND (arg, 1);
9306 if (TREE_CODE (arg) == OFFSET_REF)
9307 arg = TREE_OPERAND (arg, 1);
9309 /* Strip baselink information. */
9310 if (BASELINK_P (arg))
9311 arg = BASELINK_FUNCTIONS (arg);
9313 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
9315 /* If we got some explicit template args, we need to plug them into
9316 the affected templates before we try to unify, in case the
9317 explicit args will completely resolve the templates in question. */
9319 tree expl_subargs = TREE_OPERAND (arg, 1);
9320 arg = TREE_OPERAND (arg, 0);
9322 for (; arg; arg = OVL_NEXT (arg))
9324 tree fn = OVL_CURRENT (arg);
9327 if (TREE_CODE (fn) != TEMPLATE_DECL)
9330 subargs = get_bindings_overload (fn, DECL_TEMPLATE_RESULT (fn),
9334 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
9335 good += try_one_overload (tparms, targs, tempargs, parm,
9336 elem, strict, sub_strict, addr_p);
9340 else if (TREE_CODE (arg) == OVERLOAD
9341 || TREE_CODE (arg) == FUNCTION_DECL)
9343 for (; arg; arg = OVL_NEXT (arg))
9344 good += try_one_overload (tparms, targs, tempargs, parm,
9345 TREE_TYPE (OVL_CURRENT (arg)),
9346 strict, sub_strict, addr_p);
9351 /* [temp.deduct.type] A template-argument can be deduced from a pointer
9352 to function or pointer to member function argument if the set of
9353 overloaded functions does not contain function templates and at most
9354 one of a set of overloaded functions provides a unique match.
9356 So if we found multiple possibilities, we return success but don't
9361 int i = TREE_VEC_LENGTH (targs);
9363 if (TREE_VEC_ELT (tempargs, i))
9364 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
9372 /* Subroutine of resolve_overloaded_unification; does deduction for a single
9373 overload. Fills TARGS with any deduced arguments, or error_mark_node if
9374 different overloads deduce different arguments for a given parm.
9375 ADDR_P is true if the expression for which deduction is being
9376 performed was of the form "& fn" rather than simply "fn".
9378 Returns 1 on success. */
9381 try_one_overload (tree tparms,
9386 unification_kind_t strict,
9394 /* [temp.deduct.type] A template-argument can be deduced from a pointer
9395 to function or pointer to member function argument if the set of
9396 overloaded functions does not contain function templates and at most
9397 one of a set of overloaded functions provides a unique match.
9399 So if this is a template, just return success. */
9401 if (uses_template_parms (arg))
9404 if (TREE_CODE (arg) == METHOD_TYPE)
9405 arg = build_ptrmemfunc_type (build_pointer_type (arg));
9407 arg = build_pointer_type (arg);
9409 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9411 /* We don't copy orig_targs for this because if we have already deduced
9412 some template args from previous args, unify would complain when we
9413 try to deduce a template parameter for the same argument, even though
9414 there isn't really a conflict. */
9415 nargs = TREE_VEC_LENGTH (targs);
9416 tempargs = make_tree_vec (nargs);
9418 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
9421 /* First make sure we didn't deduce anything that conflicts with
9422 explicitly specified args. */
9423 for (i = nargs; i--; )
9425 tree elt = TREE_VEC_ELT (tempargs, i);
9426 tree oldelt = TREE_VEC_ELT (orig_targs, i);
9428 if (elt == NULL_TREE)
9430 else if (uses_template_parms (elt))
9432 /* Since we're unifying against ourselves, we will fill in template
9433 args used in the function parm list with our own template parms.
9435 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
9438 else if (oldelt && ! template_args_equal (oldelt, elt))
9442 for (i = nargs; i--; )
9444 tree elt = TREE_VEC_ELT (tempargs, i);
9447 TREE_VEC_ELT (targs, i) = elt;
9453 /* Verify that nondeduce template argument agrees with the type
9454 obtained from argument deduction. Return nonzero if the
9459 struct A { typedef int X; };
9460 template <class T, class U> struct C {};
9461 template <class T> struct C<T, typename T::X> {};
9463 Then with the instantiation `C<A, int>', we can deduce that
9464 `T' is `A' but unify () does not check whether `typename T::X'
9465 is `int'. This function ensure that they agree.
9467 TARGS, PARMS are the same as the arguments of unify.
9468 ARGS contains template arguments from all levels. */
9471 verify_class_unification (tree targs, tree parms, tree args)
9473 parms = tsubst (parms, add_outermost_template_args (args, targs),
9474 tf_none, NULL_TREE);
9475 if (parms == error_mark_node)
9478 return !comp_template_args (parms, INNERMOST_TEMPLATE_ARGS (args));
9481 /* PARM is a template class (perhaps with unbound template
9482 parameters). ARG is a fully instantiated type. If ARG can be
9483 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
9484 TARGS are as for unify. */
9487 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
9491 if (!CLASSTYPE_TEMPLATE_INFO (arg)
9492 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
9493 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
9496 /* We need to make a new template argument vector for the call to
9497 unify. If we used TARGS, we'd clutter it up with the result of
9498 the attempted unification, even if this class didn't work out.
9499 We also don't want to commit ourselves to all the unifications
9500 we've already done, since unification is supposed to be done on
9501 an argument-by-argument basis. In other words, consider the
9502 following pathological case:
9504 template <int I, int J, int K>
9507 template <int I, int J>
9508 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
9510 template <int I, int J, int K>
9511 void f(S<I, J, K>, S<I, I, I>);
9520 Now, by the time we consider the unification involving `s2', we
9521 already know that we must have `f<0, 0, 0>'. But, even though
9522 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
9523 because there are two ways to unify base classes of S<0, 1, 2>
9524 with S<I, I, I>. If we kept the already deduced knowledge, we
9525 would reject the possibility I=1. */
9526 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
9528 /* If unification failed, we're done. */
9529 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
9530 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
9536 /* Subroutine of get_template_base. RVAL, if non-NULL, is a base we
9537 have already discovered to be satisfactory. ARG_BINFO is the binfo
9538 for the base class of ARG that we are currently examining. */
9541 get_template_base_recursive (tree tparms,
9550 tree arg = BINFO_TYPE (arg_binfo);
9552 if (!(flags & GTB_IGNORE_TYPE))
9554 tree r = try_class_unification (tparms, targs,
9557 /* If there is more than one satisfactory baseclass, then:
9561 If they yield more than one possible deduced A, the type
9565 if (r && rval && !same_type_p (r, rval))
9566 return error_mark_node;
9571 binfos = BINFO_BASETYPES (arg_binfo);
9572 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
9574 /* Process base types. */
9575 for (i = 0; i < n_baselinks; i++)
9577 tree base_binfo = TREE_VEC_ELT (binfos, i);
9580 /* Skip this base, if we've already seen it. */
9581 if (BINFO_MARKED (base_binfo))
9585 (flags & GTB_VIA_VIRTUAL) || TREE_VIA_VIRTUAL (base_binfo);
9587 /* When searching for a non-virtual, we cannot mark virtually
9590 BINFO_MARKED (base_binfo) = 1;
9592 rval = get_template_base_recursive (tparms, targs,
9596 GTB_VIA_VIRTUAL * this_virtual);
9598 /* If we discovered more than one matching base class, we can
9600 if (rval == error_mark_node)
9601 return error_mark_node;
9607 /* Given a template type PARM and a class type ARG, find the unique
9608 base type in ARG that is an instance of PARM. We do not examine
9609 ARG itself; only its base-classes. If there is no appropriate base
9610 class, return NULL_TREE. If there is more than one, return
9611 error_mark_node. PARM may be the type of a partial specialization,
9612 as well as a plain template type. Used by unify. */
9615 get_template_base (tree tparms, tree targs, tree parm, tree arg)
9620 my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)), 92);
9622 arg_binfo = TYPE_BINFO (complete_type (arg));
9623 rval = get_template_base_recursive (tparms, targs,
9628 /* Since get_template_base_recursive marks the bases classes, we
9629 must unmark them here. */
9630 dfs_walk (arg_binfo, dfs_unmark, markedp, 0);
9635 /* Returns the level of DECL, which declares a template parameter. */
9638 template_decl_level (tree decl)
9640 switch (TREE_CODE (decl))
9644 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
9647 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
9655 /* Decide whether ARG can be unified with PARM, considering only the
9656 cv-qualifiers of each type, given STRICT as documented for unify.
9657 Returns nonzero iff the unification is OK on that basis. */
9660 check_cv_quals_for_unify (int strict, tree arg, tree parm)
9662 int arg_quals = cp_type_quals (arg);
9663 int parm_quals = cp_type_quals (parm);
9665 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
9666 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
9668 /* Although a CVR qualifier is ignored when being applied to a
9669 substituted template parameter ([8.3.2]/1 for example), that
9670 does not apply during deduction [14.8.2.4]/1, (even though
9671 that is not explicitly mentioned, [14.8.2.4]/9 indicates
9672 this). Except when we're allowing additional CV qualifiers
9673 at the outer level [14.8.2.1]/3,1st bullet. */
9674 if ((TREE_CODE (arg) == REFERENCE_TYPE
9675 || TREE_CODE (arg) == FUNCTION_TYPE
9676 || TREE_CODE (arg) == METHOD_TYPE)
9677 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
9680 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
9681 && (parm_quals & TYPE_QUAL_RESTRICT))
9685 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
9686 && (arg_quals & parm_quals) != parm_quals)
9689 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
9690 && (parm_quals & arg_quals) != arg_quals)
9696 /* Takes parameters as for type_unification. Returns 0 if the
9697 type deduction succeeds, 1 otherwise. The parameter STRICT is a
9698 bitwise or of the following flags:
9701 Require an exact match between PARM and ARG.
9702 UNIFY_ALLOW_MORE_CV_QUAL:
9703 Allow the deduced ARG to be more cv-qualified (by qualification
9704 conversion) than ARG.
9705 UNIFY_ALLOW_LESS_CV_QUAL:
9706 Allow the deduced ARG to be less cv-qualified than ARG.
9707 UNIFY_ALLOW_DERIVED:
9708 Allow the deduced ARG to be a template base class of ARG,
9709 or a pointer to a template base class of the type pointed to by
9711 UNIFY_ALLOW_INTEGER:
9712 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
9713 case for more information.
9714 UNIFY_ALLOW_OUTER_LEVEL:
9715 This is the outermost level of a deduction. Used to determine validity
9716 of qualification conversions. A valid qualification conversion must
9717 have const qualified pointers leading up to the inner type which
9718 requires additional CV quals, except at the outer level, where const
9719 is not required [conv.qual]. It would be normal to set this flag in
9720 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
9721 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
9722 This is the outermost level of a deduction, and PARM can be more CV
9723 qualified at this point.
9724 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
9725 This is the outermost level of a deduction, and PARM can be less CV
9726 qualified at this point.
9727 UNIFY_ALLOW_MAX_CORRECTION:
9728 This is an INTEGER_TYPE's maximum value. Used if the range may
9729 have been derived from a size specification, such as an array size.
9730 If the size was given by a nontype template parameter N, the maximum
9731 value will have the form N-1. The flag says that we can (and indeed
9732 must) unify N with (ARG + 1), an exception to the normal rules on
9736 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
9741 int strict_in = strict;
9743 /* I don't think this will do the right thing with respect to types.
9744 But the only case I've seen it in so far has been array bounds, where
9745 signedness is the only information lost, and I think that will be
9747 while (TREE_CODE (parm) == NOP_EXPR)
9748 parm = TREE_OPERAND (parm, 0);
9750 if (arg == error_mark_node)
9752 if (arg == unknown_type_node)
9753 /* We can't deduce anything from this, but we might get all the
9754 template args from other function args. */
9757 /* If PARM uses template parameters, then we can't bail out here,
9758 even if ARG == PARM, since we won't record unifications for the
9759 template parameters. We might need them if we're trying to
9760 figure out which of two things is more specialized. */
9761 if (arg == parm && !uses_template_parms (parm))
9764 /* Immediately reject some pairs that won't unify because of
9765 cv-qualification mismatches. */
9766 if (TREE_CODE (arg) == TREE_CODE (parm)
9768 /* It is the elements of the array which hold the cv quals of an array
9769 type, and the elements might be template type parms. We'll check
9771 && TREE_CODE (arg) != ARRAY_TYPE
9772 /* We check the cv-qualifiers when unifying with template type
9773 parameters below. We want to allow ARG `const T' to unify with
9774 PARM `T' for example, when computing which of two templates
9775 is more specialized, for example. */
9776 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
9777 && !check_cv_quals_for_unify (strict_in, arg, parm))
9780 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
9781 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
9782 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
9783 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
9784 strict &= ~UNIFY_ALLOW_DERIVED;
9785 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9786 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
9787 strict &= ~UNIFY_ALLOW_MAX_CORRECTION;
9789 switch (TREE_CODE (parm))
9793 case UNBOUND_CLASS_TEMPLATE:
9794 /* In a type which contains a nested-name-specifier, template
9795 argument values cannot be deduced for template parameters used
9796 within the nested-name-specifier. */
9799 case TEMPLATE_TYPE_PARM:
9800 case TEMPLATE_TEMPLATE_PARM:
9801 case BOUND_TEMPLATE_TEMPLATE_PARM:
9802 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
9804 if (TEMPLATE_TYPE_LEVEL (parm)
9805 != template_decl_level (tparm))
9806 /* The PARM is not one we're trying to unify. Just check
9807 to see if it matches ARG. */
9808 return (TREE_CODE (arg) == TREE_CODE (parm)
9809 && same_type_p (parm, arg)) ? 0 : 1;
9810 idx = TEMPLATE_TYPE_IDX (parm);
9811 targ = TREE_VEC_ELT (targs, idx);
9812 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
9814 /* Check for mixed types and values. */
9815 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
9816 && TREE_CODE (tparm) != TYPE_DECL)
9817 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
9818 && TREE_CODE (tparm) != TEMPLATE_DECL))
9821 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
9823 /* ARG must be constructed from a template class or a template
9824 template parameter. */
9825 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
9826 && (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg)))
9830 tree parmtmpl = TYPE_TI_TEMPLATE (parm);
9831 tree parmvec = TYPE_TI_ARGS (parm);
9832 tree argvec = TYPE_TI_ARGS (arg);
9834 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
9837 /* The parameter and argument roles have to be switched here
9838 in order to handle default arguments properly. For example,
9839 template<template <class> class TT> void f(TT<int>)
9840 should be able to accept vector<int> which comes from
9841 template <class T, class Allocator = allocator>
9844 if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1)
9848 /* Deduce arguments T, i from TT<T> or TT<i>.
9849 We check each element of PARMVEC and ARGVEC individually
9850 rather than the whole TREE_VEC since they can have
9851 different number of elements. */
9853 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
9855 tree t = TREE_VEC_ELT (parmvec, i);
9857 if (unify (tparms, targs, t,
9858 TREE_VEC_ELT (argvec, i),
9863 arg = TYPE_TI_TEMPLATE (arg);
9865 /* Fall through to deduce template name. */
9868 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
9869 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
9871 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
9873 /* Simple cases: Value already set, does match or doesn't. */
9874 if (targ != NULL_TREE && template_args_equal (targ, arg))
9881 /* If PARM is `const T' and ARG is only `int', we don't have
9882 a match unless we are allowing additional qualification.
9883 If ARG is `const int' and PARM is just `T' that's OK;
9884 that binds `const int' to `T'. */
9885 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
9889 /* Consider the case where ARG is `const volatile int' and
9890 PARM is `const T'. Then, T should be `volatile int'. */
9891 arg = cp_build_qualified_type_real
9892 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
9893 if (arg == error_mark_node)
9896 /* Simple cases: Value already set, does match or doesn't. */
9897 if (targ != NULL_TREE && same_type_p (targ, arg))
9902 /* Make sure that ARG is not a variable-sized array. (Note
9903 that were talking about variable-sized arrays (like
9904 `int[n]'), rather than arrays of unknown size (like
9905 `int[]').) We'll get very confused by such a type since
9906 the bound of the array will not be computable in an
9907 instantiation. Besides, such types are not allowed in
9908 ISO C++, so we can do as we please here. */
9909 if (variably_modified_type_p (arg))
9913 TREE_VEC_ELT (targs, idx) = arg;
9916 case TEMPLATE_PARM_INDEX:
9917 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
9919 if (TEMPLATE_PARM_LEVEL (parm)
9920 != template_decl_level (tparm))
9921 /* The PARM is not one we're trying to unify. Just check
9922 to see if it matches ARG. */
9923 return !(TREE_CODE (arg) == TREE_CODE (parm)
9924 && cp_tree_equal (parm, arg));
9926 idx = TEMPLATE_PARM_IDX (parm);
9927 targ = TREE_VEC_ELT (targs, idx);
9930 return !cp_tree_equal (targ, arg);
9932 /* [temp.deduct.type] If, in the declaration of a function template
9933 with a non-type template-parameter, the non-type
9934 template-parameter is used in an expression in the function
9935 parameter-list and, if the corresponding template-argument is
9936 deduced, the template-argument type shall match the type of the
9937 template-parameter exactly, except that a template-argument
9938 deduced from an array bound may be of any integral type.
9939 The non-type parameter might use already deduced type parameters. */
9940 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
9941 if (!TREE_TYPE (arg))
9942 /* Template-parameter dependent expression. Just accept it for now.
9943 It will later be processed in convert_template_argument. */
9945 else if (same_type_p (TREE_TYPE (arg), tparm))
9947 else if ((strict & UNIFY_ALLOW_INTEGER)
9948 && (TREE_CODE (tparm) == INTEGER_TYPE
9949 || TREE_CODE (tparm) == BOOLEAN_TYPE))
9950 /* Convert the ARG to the type of PARM; the deduced non-type
9951 template argument must exactly match the types of the
9952 corresponding parameter. */
9953 arg = fold (build_nop (TREE_TYPE (parm), arg));
9954 else if (uses_template_parms (tparm))
9955 /* We haven't deduced the type of this parameter yet. Try again
9961 TREE_VEC_ELT (targs, idx) = arg;
9966 /* A pointer-to-member constant can be unified only with
9967 another constant. */
9968 if (TREE_CODE (arg) != PTRMEM_CST)
9971 /* Just unify the class member. It would be useless (and possibly
9972 wrong, depending on the strict flags) to unify also
9973 PTRMEM_CST_CLASS, because we want to be sure that both parm and
9974 arg refer to the same variable, even if through different
9975 classes. For instance:
9977 struct A { int x; };
9980 Unification of &A::x and &B::x must succeed. */
9981 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
9982 PTRMEM_CST_MEMBER (arg), strict);
9987 if (TREE_CODE (arg) != POINTER_TYPE)
9990 /* [temp.deduct.call]
9992 A can be another pointer or pointer to member type that can
9993 be converted to the deduced A via a qualification
9994 conversion (_conv.qual_).
9996 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
9997 This will allow for additional cv-qualification of the
9998 pointed-to types if appropriate. */
10000 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10001 /* The derived-to-base conversion only persists through one
10002 level of pointers. */
10003 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10005 return unify (tparms, targs, TREE_TYPE (parm),
10006 TREE_TYPE (arg), strict);
10009 case REFERENCE_TYPE:
10010 if (TREE_CODE (arg) != REFERENCE_TYPE)
10012 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10013 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10016 if (TREE_CODE (arg) != ARRAY_TYPE)
10018 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10019 != (TYPE_DOMAIN (arg) == NULL_TREE))
10021 if (TYPE_DOMAIN (parm) != NULL_TREE
10022 && unify (tparms, targs, TYPE_DOMAIN (parm),
10023 TYPE_DOMAIN (arg), UNIFY_ALLOW_NONE) != 0)
10025 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10026 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10033 case ENUMERAL_TYPE:
10035 if (TREE_CODE (arg) != TREE_CODE (parm))
10038 if (TREE_CODE (parm) == INTEGER_TYPE
10039 && TREE_CODE (TYPE_MAX_VALUE (parm)) != INTEGER_CST)
10041 if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg)
10042 && unify (tparms, targs, TYPE_MIN_VALUE (parm),
10043 TYPE_MIN_VALUE (arg), UNIFY_ALLOW_INTEGER))
10045 if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg)
10046 && unify (tparms, targs, TYPE_MAX_VALUE (parm),
10047 TYPE_MAX_VALUE (arg),
10048 UNIFY_ALLOW_INTEGER | UNIFY_ALLOW_MAX_CORRECTION))
10051 /* We have already checked cv-qualification at the top of the
10053 else if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10056 /* As far as unification is concerned, this wins. Later checks
10057 will invalidate it if necessary. */
10060 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10061 /* Type INTEGER_CST can come from ordinary constant template args. */
10063 while (TREE_CODE (arg) == NOP_EXPR)
10064 arg = TREE_OPERAND (arg, 0);
10066 if (TREE_CODE (arg) != INTEGER_CST)
10068 return !tree_int_cst_equal (parm, arg);
10073 if (TREE_CODE (arg) != TREE_VEC)
10075 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10077 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10078 if (unify (tparms, targs,
10079 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10087 if (TREE_CODE (arg) != TREE_CODE (parm))
10090 if (TYPE_PTRMEMFUNC_P (parm))
10092 if (!TYPE_PTRMEMFUNC_P (arg))
10095 return unify (tparms, targs,
10096 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10097 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10101 if (CLASSTYPE_TEMPLATE_INFO (parm))
10103 tree t = NULL_TREE;
10105 if (strict_in & UNIFY_ALLOW_DERIVED)
10107 /* First, we try to unify the PARM and ARG directly. */
10108 t = try_class_unification (tparms, targs,
10113 /* Fallback to the special case allowed in
10114 [temp.deduct.call]:
10116 If P is a class, and P has the form
10117 template-id, then A can be a derived class of
10118 the deduced A. Likewise, if P is a pointer to
10119 a class of the form template-id, A can be a
10120 pointer to a derived class pointed to by the
10122 t = get_template_base (tparms, targs,
10125 if (! t || t == error_mark_node)
10129 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10130 && (CLASSTYPE_TI_TEMPLATE (parm)
10131 == CLASSTYPE_TI_TEMPLATE (arg)))
10132 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10133 Then, we should unify `int' and `U'. */
10136 /* There's no chance of unification succeeding. */
10139 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10140 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10142 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10147 case FUNCTION_TYPE:
10148 if (TREE_CODE (arg) != TREE_CODE (parm))
10151 if (unify (tparms, targs, TREE_TYPE (parm),
10152 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10154 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10155 TYPE_ARG_TYPES (arg), 1,
10156 DEDUCE_EXACT, 0, -1);
10159 if (TREE_CODE (arg) != OFFSET_TYPE)
10161 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10162 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10164 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10168 if (DECL_TEMPLATE_PARM_P (parm))
10169 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10170 if (arg != decl_constant_value (parm))
10175 case TEMPLATE_DECL:
10176 /* Matched cases are handled by the ARG == PARM test above. */
10180 if (tree_int_cst_equal (TREE_OPERAND (parm, 1), integer_one_node)
10181 && (strict_in & UNIFY_ALLOW_MAX_CORRECTION))
10183 /* We handle this case specially, since it comes up with
10184 arrays. In particular, something like:
10186 template <int N> void f(int (&x)[N]);
10188 Here, we are trying to unify the range type, which
10189 looks like [0 ... (N - 1)]. */
10191 t1 = TREE_OPERAND (parm, 0);
10192 t2 = TREE_OPERAND (parm, 1);
10194 t = fold (build (PLUS_EXPR, integer_type_node, arg, t2));
10196 return unify (tparms, targs, t1, t, strict);
10198 /* Else fall through. */
10201 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm))))
10204 /* We're looking at an expression. This can happen with
10208 void foo(S<I>, S<I + 2>);
10210 This is a "nondeduced context":
10214 The nondeduced contexts are:
10216 --A type that is a template-id in which one or more of
10217 the template-arguments is an expression that references
10218 a template-parameter.
10220 In these cases, we assume deduction succeeded, but don't
10221 actually infer any unifications. */
10223 if (!uses_template_parms (parm)
10224 && !template_args_equal (parm, arg))
10229 sorry ("use of `%s' in template type unification",
10230 tree_code_name [(int) TREE_CODE (parm)]);
10235 /* Called if RESULT is explicitly instantiated, or is a member of an
10236 explicitly instantiated class, or if using -frepo and the
10237 instantiation of RESULT has been assigned to this file. */
10240 mark_decl_instantiated (tree result, int extern_p)
10242 /* We used to set this unconditionally; we moved that to
10243 do_decl_instantiation so it wouldn't get set on members of
10244 explicit class template instantiations. But we still need to set
10245 it here for the 'extern template' case in order to suppress
10246 implicit instantiations. */
10248 SET_DECL_EXPLICIT_INSTANTIATION (result);
10250 /* If this entity has already been written out, it's too late to
10251 make any modifications. */
10252 if (TREE_ASM_WRITTEN (result))
10255 if (TREE_CODE (result) != FUNCTION_DECL)
10256 /* The TREE_PUBLIC flag for function declarations will have been
10257 set correctly by tsubst. */
10258 TREE_PUBLIC (result) = 1;
10260 /* This might have been set by an earlier implicit instantiation. */
10261 DECL_COMDAT (result) = 0;
10265 DECL_INTERFACE_KNOWN (result) = 1;
10266 DECL_NOT_REALLY_EXTERN (result) = 1;
10268 /* Always make artificials weak. */
10269 if (DECL_ARTIFICIAL (result) && flag_weak)
10270 comdat_linkage (result);
10271 /* For WIN32 we also want to put explicit instantiations in
10272 linkonce sections. */
10273 else if (TREE_PUBLIC (result))
10274 maybe_make_one_only (result);
10277 if (TREE_CODE (result) == FUNCTION_DECL)
10281 /* Given two function templates PAT1 and PAT2, return:
10283 DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER.
10285 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
10286 -1 if PAT2 is more specialized than PAT1.
10287 0 if neither is more specialized.
10289 LEN is passed through to fn_type_unification. */
10292 more_specialized (tree pat1, tree pat2, int deduce, int len)
10297 /* If template argument deduction succeeds, we substitute the
10298 resulting arguments into non-deduced contexts. While doing that,
10299 we must be aware that we may encounter dependent types. */
10300 ++processing_template_decl;
10301 targs = get_bindings_real (pat1, DECL_TEMPLATE_RESULT (pat2),
10302 NULL_TREE, 0, deduce, len);
10306 targs = get_bindings_real (pat2, DECL_TEMPLATE_RESULT (pat1),
10307 NULL_TREE, 0, deduce, len);
10310 --processing_template_decl;
10315 /* Given two class template specialization list nodes PAT1 and PAT2, return:
10317 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
10318 -1 if PAT2 is more specialized than PAT1.
10319 0 if neither is more specialized.
10321 FULL_ARGS is the full set of template arguments that triggers this
10322 partial ordering. */
10325 more_specialized_class (tree pat1, tree pat2, tree full_args)
10330 /* Just like what happens for functions, if we are ordering between
10331 different class template specializations, we may encounter dependent
10332 types in the arguments, and we need our dependency check functions
10333 to behave correctly. */
10334 ++processing_template_decl;
10335 targs = get_class_bindings (TREE_VALUE (pat1), TREE_PURPOSE (pat1),
10336 add_outermost_template_args (full_args, TREE_PURPOSE (pat2)));
10340 targs = get_class_bindings (TREE_VALUE (pat2), TREE_PURPOSE (pat2),
10341 add_outermost_template_args (full_args, TREE_PURPOSE (pat1)));
10344 --processing_template_decl;
10349 /* Return the template arguments that will produce the function signature
10350 DECL from the function template FN, with the explicit template
10351 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
10352 also match. Return NULL_TREE if no satisfactory arguments could be
10353 found. DEDUCE and LEN are passed through to fn_type_unification. */
10356 get_bindings_real (tree fn,
10358 tree explicit_args,
10363 int ntparms = DECL_NTPARMS (fn);
10364 tree targs = make_tree_vec (ntparms);
10366 tree decl_arg_types;
10369 /* Substitute the explicit template arguments into the type of DECL.
10370 The call to fn_type_unification will handle substitution into the
10372 decl_type = TREE_TYPE (decl);
10373 if (explicit_args && uses_template_parms (decl_type))
10376 tree converted_args;
10378 if (DECL_TEMPLATE_INFO (decl))
10379 tmpl = DECL_TI_TEMPLATE (decl);
10381 /* We can get here for some invalid specializations. */
10385 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
10386 explicit_args, NULL_TREE,
10387 tf_none, /*require_all_arguments=*/0));
10388 if (converted_args == error_mark_node)
10391 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
10392 if (decl_type == error_mark_node)
10396 decl_arg_types = TYPE_ARG_TYPES (decl_type);
10397 /* Never do unification on the 'this' parameter. */
10398 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
10399 decl_arg_types = TREE_CHAIN (decl_arg_types);
10401 i = fn_type_unification (fn, explicit_args, targs,
10403 (check_rettype || DECL_CONV_FN_P (fn)
10404 ? TREE_TYPE (decl_type) : NULL_TREE),
10413 /* For most uses, we want to check the return type. */
10416 get_bindings (tree fn, tree decl, tree explicit_args)
10418 return get_bindings_real (fn, decl, explicit_args, 1, DEDUCE_EXACT, -1);
10421 /* But for resolve_overloaded_unification, we only care about the parameter
10425 get_bindings_overload (tree fn, tree decl, tree explicit_args)
10427 return get_bindings_real (fn, decl, explicit_args, 0, DEDUCE_EXACT, -1);
10430 /* Return the innermost template arguments that, when applied to a
10431 template specialization whose innermost template parameters are
10432 TPARMS, and whose specialization arguments are PARMS, yield the
10435 For example, suppose we have:
10437 template <class T, class U> struct S {};
10438 template <class T> struct S<T*, int> {};
10440 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
10441 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
10442 int}. The resulting vector will be {double}, indicating that `T'
10443 is bound to `double'. */
10446 get_class_bindings (tree tparms, tree parms, tree args)
10448 int i, ntparms = TREE_VEC_LENGTH (tparms);
10449 tree vec = make_tree_vec (ntparms);
10451 if (unify (tparms, vec, parms, INNERMOST_TEMPLATE_ARGS (args),
10455 for (i = 0; i < ntparms; ++i)
10456 if (! TREE_VEC_ELT (vec, i))
10459 if (verify_class_unification (vec, parms, args))
10465 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
10466 Pick the most specialized template, and return the corresponding
10467 instantiation, or if there is no corresponding instantiation, the
10468 template itself. If there is no most specialized template,
10469 error_mark_node is returned. If there are no templates at all,
10470 NULL_TREE is returned. */
10473 most_specialized_instantiation (tree instantiations)
10478 if (!instantiations)
10481 champ = instantiations;
10482 for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn))
10484 fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn),
10492 fn = TREE_CHAIN (fn);
10494 return error_mark_node;
10500 for (fn = instantiations; fn && fn != champ; fn = TREE_CHAIN (fn))
10502 fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn),
10505 return error_mark_node;
10508 return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ);
10511 /* Return the most specialized of the list of templates in FNS that can
10512 produce an instantiation matching DECL, given the explicit template
10513 arguments EXPLICIT_ARGS. */
10516 most_specialized (tree fns, tree decl, tree explicit_args)
10518 tree candidates = NULL_TREE;
10521 for (fn = fns; fn; fn = TREE_CHAIN (fn))
10523 tree candidate = TREE_VALUE (fn);
10525 args = get_bindings (candidate, decl, explicit_args);
10527 candidates = tree_cons (NULL_TREE, candidate, candidates);
10530 return most_specialized_instantiation (candidates);
10533 /* If DECL is a specialization of some template, return the most
10534 general such template. Otherwise, returns NULL_TREE.
10536 For example, given:
10538 template <class T> struct S { template <class U> void f(U); };
10540 if TMPL is `template <class U> void S<int>::f(U)' this will return
10541 the full template. This function will not trace past partial
10542 specializations, however. For example, given in addition:
10544 template <class T> struct S<T*> { template <class U> void f(U); };
10546 if TMPL is `template <class U> void S<int*>::f(U)' this will return
10547 `template <class T> template <class U> S<T*>::f(U)'. */
10550 most_general_template (tree decl)
10552 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
10553 an immediate specialization. */
10554 if (TREE_CODE (decl) == FUNCTION_DECL)
10556 if (DECL_TEMPLATE_INFO (decl)) {
10557 decl = DECL_TI_TEMPLATE (decl);
10559 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
10560 template friend. */
10561 if (TREE_CODE (decl) != TEMPLATE_DECL)
10567 /* Look for more and more general templates. */
10568 while (DECL_TEMPLATE_INFO (decl))
10570 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
10571 (See cp-tree.h for details.) */
10572 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
10575 if (CLASS_TYPE_P (TREE_TYPE (decl))
10576 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
10579 /* Stop if we run into an explicitly specialized class template. */
10580 if (!DECL_NAMESPACE_SCOPE_P (decl)
10581 && DECL_CONTEXT (decl)
10582 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
10585 decl = DECL_TI_TEMPLATE (decl);
10591 /* Return the most specialized of the class template specializations
10592 of TMPL which can produce an instantiation matching ARGS, or
10593 error_mark_node if the choice is ambiguous. */
10596 most_specialized_class (tree tmpl, tree args)
10598 tree list = NULL_TREE;
10603 tmpl = most_general_template (tmpl);
10604 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
10607 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args);
10610 list = tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list);
10611 TREE_TYPE (list) = TREE_TYPE (t);
10620 t = TREE_CHAIN (t);
10621 for (; t; t = TREE_CHAIN (t))
10623 fate = more_specialized_class (champ, t, args);
10630 t = TREE_CHAIN (t);
10632 return error_mark_node;
10638 for (t = list; t && t != champ; t = TREE_CHAIN (t))
10640 fate = more_specialized_class (champ, t, args);
10642 return error_mark_node;
10648 /* Explicitly instantiate DECL. */
10651 do_decl_instantiation (tree decl, tree storage)
10653 tree result = NULL_TREE;
10657 /* An error occurred, for which grokdeclarator has already issued
10658 an appropriate message. */
10660 else if (! DECL_LANG_SPECIFIC (decl))
10662 error ("explicit instantiation of non-template `%#D'", decl);
10665 else if (TREE_CODE (decl) == VAR_DECL)
10667 /* There is an asymmetry here in the way VAR_DECLs and
10668 FUNCTION_DECLs are handled by grokdeclarator. In the case of
10669 the latter, the DECL we get back will be marked as a
10670 template instantiation, and the appropriate
10671 DECL_TEMPLATE_INFO will be set up. This does not happen for
10672 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
10673 should handle VAR_DECLs as it currently handles
10675 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
10676 if (!result || TREE_CODE (result) != VAR_DECL)
10678 error ("no matching template for `%D' found", decl);
10682 else if (TREE_CODE (decl) != FUNCTION_DECL)
10684 error ("explicit instantiation of `%#D'", decl);
10690 /* Check for various error cases. Note that if the explicit
10691 instantiation is valid the RESULT will currently be marked as an
10692 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
10693 until we get here. */
10695 if (DECL_TEMPLATE_SPECIALIZATION (result))
10697 /* DR 259 [temp.spec].
10699 Both an explicit instantiation and a declaration of an explicit
10700 specialization shall not appear in a program unless the explicit
10701 instantiation follows a declaration of the explicit specialization.
10703 For a given set of template parameters, if an explicit
10704 instantiation of a template appears after a declaration of an
10705 explicit specialization for that template, the explicit
10706 instantiation has no effect. */
10709 else if (DECL_EXPLICIT_INSTANTIATION (result))
10713 No program shall explicitly instantiate any template more
10716 We check DECL_INTERFACE_KNOWN so as not to complain when the first
10717 instantiation was `extern' and the second is not, and EXTERN_P for
10718 the opposite case. If -frepo, chances are we already got marked
10719 as an explicit instantiation because of the repo file. */
10720 if (DECL_INTERFACE_KNOWN (result) && !extern_p && !flag_use_repository)
10721 pedwarn ("duplicate explicit instantiation of `%#D'", result);
10723 /* If we've already instantiated the template, just return now. */
10724 if (DECL_INTERFACE_KNOWN (result))
10727 else if (!DECL_IMPLICIT_INSTANTIATION (result))
10729 error ("no matching template for `%D' found", result);
10732 else if (!DECL_TEMPLATE_INFO (result))
10734 pedwarn ("explicit instantiation of non-template `%#D'", result);
10738 if (storage == NULL_TREE)
10740 else if (storage == ridpointers[(int) RID_EXTERN])
10742 if (pedantic && !in_system_header)
10743 pedwarn ("ISO C++ forbids the use of `extern' on explicit instantiations");
10747 error ("storage class `%D' applied to template instantiation",
10750 SET_DECL_EXPLICIT_INSTANTIATION (result);
10751 mark_decl_instantiated (result, extern_p);
10752 repo_template_instantiated (result, extern_p);
10754 instantiate_decl (result, /*defer_ok=*/1);
10758 mark_class_instantiated (tree t, int extern_p)
10760 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
10761 SET_CLASSTYPE_INTERFACE_KNOWN (t);
10762 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
10763 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
10766 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
10767 rest_of_type_compilation (t, 1);
10771 /* Called from do_type_instantiation through binding_table_foreach to
10772 do recursive instantiation for the type bound in ENTRY. */
10774 bt_instantiate_type_proc (binding_entry entry, void *data)
10776 tree storage = *(tree *) data;
10778 if (IS_AGGR_TYPE (entry->type)
10779 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
10780 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
10783 /* Perform an explicit instantiation of template class T. STORAGE, if
10784 non-null, is the RID for extern, inline or static. COMPLAIN is
10785 nonzero if this is called from the parser, zero if called recursively,
10786 since the standard is unclear (as detailed below). */
10789 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
10795 if (TREE_CODE (t) == TYPE_DECL)
10798 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
10800 error ("explicit instantiation of non-template type `%T'", t);
10806 if (!COMPLETE_TYPE_P (t))
10808 if (complain & tf_error)
10809 error ("explicit instantiation of `%#T' before definition of template",
10814 if (storage != NULL_TREE)
10816 if (pedantic && !in_system_header)
10817 pedwarn("ISO C++ forbids the use of `%s' on explicit instantiations",
10818 IDENTIFIER_POINTER (storage));
10820 if (storage == ridpointers[(int) RID_INLINE])
10822 else if (storage == ridpointers[(int) RID_EXTERN])
10824 else if (storage == ridpointers[(int) RID_STATIC])
10828 error ("storage class `%D' applied to template instantiation",
10834 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10836 /* DR 259 [temp.spec].
10838 Both an explicit instantiation and a declaration of an explicit
10839 specialization shall not appear in a program unless the explicit
10840 instantiation follows a declaration of the explicit specialization.
10842 For a given set of template parameters, if an explicit
10843 instantiation of a template appears after a declaration of an
10844 explicit specialization for that template, the explicit
10845 instantiation has no effect. */
10848 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
10852 No program shall explicitly instantiate any template more
10855 If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation
10856 was `extern'. If EXTERN_P then the second is. If -frepo, chances
10857 are we already got marked as an explicit instantiation because of the
10858 repo file. All these cases are OK. */
10859 if (!CLASSTYPE_INTERFACE_ONLY (t) && !extern_p && !flag_use_repository
10860 && (complain & tf_error))
10861 pedwarn ("duplicate explicit instantiation of `%#T'", t);
10863 /* If we've already instantiated the template, just return now. */
10864 if (!CLASSTYPE_INTERFACE_ONLY (t))
10868 mark_class_instantiated (t, extern_p);
10869 repo_template_instantiated (t, extern_p);
10877 /* In contrast to implicit instantiation, where only the
10878 declarations, and not the definitions, of members are
10879 instantiated, we have here:
10883 The explicit instantiation of a class template specialization
10884 implies the instantiation of all of its members not
10885 previously explicitly specialized in the translation unit
10886 containing the explicit instantiation.
10888 Of course, we can't instantiate member template classes, since
10889 we don't have any arguments for them. Note that the standard
10890 is unclear on whether the instantiation of the members are
10891 *explicit* instantiations or not. We choose to be generous,
10892 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
10893 the explicit instantiation of a class where some of the members
10894 have no definition in the current translation unit. */
10897 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
10898 if (TREE_CODE (tmp) == FUNCTION_DECL
10899 && DECL_TEMPLATE_INSTANTIATION (tmp))
10901 mark_decl_instantiated (tmp, extern_p);
10902 repo_template_instantiated (tmp, extern_p);
10904 instantiate_decl (tmp, /*defer_ok=*/1);
10907 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
10908 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
10910 mark_decl_instantiated (tmp, extern_p);
10911 repo_template_instantiated (tmp, extern_p);
10913 instantiate_decl (tmp, /*defer_ok=*/1);
10916 if (CLASSTYPE_NESTED_UTDS (t))
10917 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
10918 bt_instantiate_type_proc, &storage);
10922 /* Given a function DECL, which is a specialization of TMPL, modify
10923 DECL to be a re-instantiation of TMPL with the same template
10924 arguments. TMPL should be the template into which tsubst'ing
10925 should occur for DECL, not the most general template.
10927 One reason for doing this is a scenario like this:
10930 void f(const T&, int i);
10932 void g() { f(3, 7); }
10935 void f(const T& t, const int i) { }
10937 Note that when the template is first instantiated, with
10938 instantiate_template, the resulting DECL will have no name for the
10939 first parameter, and the wrong type for the second. So, when we go
10940 to instantiate the DECL, we regenerate it. */
10943 regenerate_decl_from_template (tree decl, tree tmpl)
10945 /* The most general version of TMPL. */
10947 /* The arguments used to instantiate DECL, from the most general
10954 args = DECL_TI_ARGS (decl);
10955 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
10957 /* Unregister the specialization so that when we tsubst we will not
10958 just return DECL. We don't have to unregister DECL from TMPL
10959 because if would only be registered there if it were a partial
10960 instantiation of a specialization, which it isn't: it's a full
10962 gen_tmpl = most_general_template (tmpl);
10963 unregistered = reregister_specialization (decl, gen_tmpl,
10964 /*new_spec=*/NULL_TREE);
10966 /* If the DECL was not unregistered then something peculiar is
10967 happening: we created a specialization but did not call
10968 register_specialization for it. */
10969 my_friendly_assert (unregistered, 0);
10971 /* Make sure that we can see identifiers, and compute access
10973 push_access_scope (decl);
10975 /* Do the substitution to get the new declaration. */
10976 new_decl = tsubst (code_pattern, args, tf_error, NULL_TREE);
10978 if (TREE_CODE (decl) == VAR_DECL)
10980 /* Set up DECL_INITIAL, since tsubst doesn't. */
10981 if (!DECL_INITIALIZED_IN_CLASS_P (decl))
10982 DECL_INITIAL (new_decl) =
10983 tsubst_expr (DECL_INITIAL (code_pattern), args,
10984 tf_error, DECL_TI_TEMPLATE (decl));
10986 else if (TREE_CODE (decl) == FUNCTION_DECL)
10988 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
10990 DECL_INITIAL (new_decl) = error_mark_node;
10991 /* And don't complain about a duplicate definition. */
10992 DECL_INITIAL (decl) = NULL_TREE;
10995 pop_access_scope (decl);
10997 /* The immediate parent of the new template is still whatever it was
10998 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
10999 general template. We also reset the DECL_ASSEMBLER_NAME since
11000 tsubst always calculates the name as if the function in question
11001 were really a template instance, and sometimes, with friend
11002 functions, this is not so. See tsubst_friend_function for
11004 DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl);
11005 COPY_DECL_ASSEMBLER_NAME (decl, new_decl);
11006 COPY_DECL_RTL (decl, new_decl);
11007 DECL_USE_TEMPLATE (new_decl) = DECL_USE_TEMPLATE (decl);
11009 /* Call duplicate decls to merge the old and new declarations. */
11010 duplicate_decls (new_decl, decl);
11012 /* Now, re-register the specialization. */
11013 register_specialization (decl, gen_tmpl, args);
11016 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
11017 substituted to get DECL. */
11020 template_for_substitution (tree decl)
11022 tree tmpl = DECL_TI_TEMPLATE (decl);
11024 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
11025 for the instantiation. This is not always the most general
11026 template. Consider, for example:
11029 struct S { template <class U> void f();
11030 template <> void f<int>(); };
11032 and an instantiation of S<double>::f<int>. We want TD to be the
11033 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11034 while (/* An instantiation cannot have a definition, so we need a
11035 more general template. */
11036 DECL_TEMPLATE_INSTANTIATION (tmpl)
11037 /* We must also deal with friend templates. Given:
11039 template <class T> struct S {
11040 template <class U> friend void f() {};
11043 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
11044 so far as the language is concerned, but that's still
11045 where we get the pattern for the instantiation from. On
11046 other hand, if the definition comes outside the class, say:
11048 template <class T> struct S {
11049 template <class U> friend void f();
11051 template <class U> friend void f() {}
11053 we don't need to look any further. That's what the check for
11054 DECL_INITIAL is for. */
11055 || (TREE_CODE (decl) == FUNCTION_DECL
11056 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
11057 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
11059 /* The present template, TD, should not be a definition. If it
11060 were a definition, we should be using it! Note that we
11061 cannot restructure the loop to just keep going until we find
11062 a template with a definition, since that might go too far if
11063 a specialization was declared, but not defined. */
11064 my_friendly_assert (!(TREE_CODE (decl) == VAR_DECL
11065 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl))),
11068 /* Fetch the more general template. */
11069 tmpl = DECL_TI_TEMPLATE (tmpl);
11075 /* Produce the definition of D, a _DECL generated from a template. If
11076 DEFER_OK is nonzero, then we don't have to actually do the
11077 instantiation now; we just have to do it sometime. */
11080 instantiate_decl (tree d, int defer_ok)
11082 tree tmpl = DECL_TI_TEMPLATE (d);
11089 int pattern_defined;
11091 location_t saved_loc = input_location;
11093 /* This function should only be used to instantiate templates for
11094 functions and static member variables. */
11095 my_friendly_assert (TREE_CODE (d) == FUNCTION_DECL
11096 || TREE_CODE (d) == VAR_DECL, 0);
11098 /* Variables are never deferred; if instantiation is required, they
11099 are instantiated right away. That allows for better code in the
11100 case that an expression refers to the value of the variable --
11101 if the variable has a constant value the referring expression can
11102 take advantage of that fact. */
11103 if (TREE_CODE (d) == VAR_DECL)
11106 /* Don't instantiate cloned functions. Instead, instantiate the
11107 functions they cloned. */
11108 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
11109 d = DECL_CLONED_FUNCTION (d);
11111 if (DECL_TEMPLATE_INSTANTIATED (d))
11112 /* D has already been instantiated. It might seem reasonable to
11113 check whether or not D is an explicit instantiation, and, if so,
11114 stop here. But when an explicit instantiation is deferred
11115 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
11116 is set, even though we still need to do the instantiation. */
11119 /* If we already have a specialization of this declaration, then
11120 there's no reason to instantiate it. Note that
11121 retrieve_specialization gives us both instantiations and
11122 specializations, so we must explicitly check
11123 DECL_TEMPLATE_SPECIALIZATION. */
11124 gen_tmpl = most_general_template (tmpl);
11125 gen_args = DECL_TI_ARGS (d);
11126 spec = retrieve_specialization (gen_tmpl, gen_args);
11127 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
11130 /* This needs to happen before any tsubsting. */
11131 if (! push_tinst_level (d))
11134 timevar_push (TV_PARSE);
11136 /* We may be in the middle of deferred access check. Disable it now. */
11137 push_deferring_access_checks (dk_no_deferred);
11139 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
11140 for the instantiation. */
11141 td = template_for_substitution (d);
11142 code_pattern = DECL_TEMPLATE_RESULT (td);
11144 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
11145 || DECL_TEMPLATE_SPECIALIZATION (td))
11146 /* In the case of a friend template whose definition is provided
11147 outside the class, we may have too many arguments. Drop the
11148 ones we don't need. The same is true for specializations. */
11149 args = get_innermost_template_args
11150 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
11154 if (TREE_CODE (d) == FUNCTION_DECL)
11155 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
11157 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
11159 input_location = DECL_SOURCE_LOCATION (d);
11161 if (pattern_defined)
11163 /* Let the repository code that this template definition is
11166 The repository doesn't need to know about cloned functions
11167 because they never actually show up in the object file. It
11168 does need to know about the clones; those are the symbols
11169 that the linker will be emitting error messages about. */
11170 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (d)
11171 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (d))
11175 for (t = TREE_CHAIN (d);
11176 t && DECL_CLONED_FUNCTION_P (t);
11177 t = TREE_CHAIN (t))
11178 repo_template_used (t);
11181 repo_template_used (d);
11184 import_export_decl (d);
11189 /* Recheck the substitutions to obtain any warning messages
11190 about ignoring cv qualifiers. */
11191 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
11192 tree type = TREE_TYPE (gen);
11194 /* Make sure that we can see identifiers, and compute access
11195 correctly. D is already the target FUNCTION_DECL with the
11197 push_access_scope (d);
11199 if (TREE_CODE (gen) == FUNCTION_DECL)
11201 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_error | tf_warning, d);
11202 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
11203 tf_error | tf_warning, d);
11204 /* Don't simply tsubst the function type, as that will give
11205 duplicate warnings about poor parameter qualifications.
11206 The function arguments are the same as the decl_arguments
11207 without the top level cv qualifiers. */
11208 type = TREE_TYPE (type);
11210 tsubst (type, gen_args, tf_error | tf_warning, d);
11212 pop_access_scope (d);
11215 if (TREE_CODE (d) == VAR_DECL && DECL_INITIALIZED_IN_CLASS_P (d)
11216 && DECL_INITIAL (d) == NULL_TREE)
11217 /* We should have set up DECL_INITIAL in instantiate_class_template. */
11219 /* Reject all external templates except inline functions. */
11220 else if (DECL_INTERFACE_KNOWN (d)
11221 && ! DECL_NOT_REALLY_EXTERN (d)
11222 && ! (TREE_CODE (d) == FUNCTION_DECL
11223 && DECL_INLINE (d)))
11225 /* Defer all other templates, unless we have been explicitly
11226 forbidden from doing so. We restore the source position here
11227 because it's used by add_pending_template. */
11228 else if (! pattern_defined || defer_ok)
11230 input_location = saved_loc;
11232 if (at_eof && !pattern_defined
11233 && DECL_EXPLICIT_INSTANTIATION (d))
11236 The definition of a non-exported function template, a
11237 non-exported member function template, or a non-exported
11238 member function or static data member of a class template
11239 shall be present in every translation unit in which it is
11240 explicitly instantiated. */
11242 ("explicit instantiation of `%D' but no definition available", d);
11244 add_pending_template (d);
11248 need_push = !global_bindings_p ();
11250 push_to_top_level ();
11252 /* Mark D as instantiated so that recursive calls to
11253 instantiate_decl do not try to instantiate it again. */
11254 DECL_TEMPLATE_INSTANTIATED (d) = 1;
11256 /* Regenerate the declaration in case the template has been modified
11257 by a subsequent redeclaration. */
11258 regenerate_decl_from_template (d, td);
11260 /* We already set the file and line above. Reset them now in case
11261 they changed as a result of calling
11262 regenerate_decl_from_template. */
11263 input_location = DECL_SOURCE_LOCATION (d);
11265 if (TREE_CODE (d) == VAR_DECL)
11267 /* Clear out DECL_RTL; whatever was there before may not be right
11268 since we've reset the type of the declaration. */
11269 SET_DECL_RTL (d, NULL_RTX);
11271 DECL_IN_AGGR_P (d) = 0;
11272 import_export_decl (d);
11273 DECL_EXTERNAL (d) = ! DECL_NOT_REALLY_EXTERN (d);
11275 if (DECL_EXTERNAL (d))
11277 /* The fact that this code is executing indicates that:
11279 (1) D is a template static data member, for which a
11280 definition is available.
11282 (2) An implicit or explicit instantiation has occurred.
11284 (3) We are not going to emit a definition of the static
11285 data member at this time.
11287 This situation is peculiar, but it occurs on platforms
11288 without weak symbols when performing an implicit
11289 instantiation. There, we cannot implicitly instantiate a
11290 defined static data member in more than one translation
11291 unit, so import_export_decl marks the declaration as
11292 external; we must rely on explicit instantiation.
11294 Reset instantiated marker to make sure that later
11295 explicit instantiation will be processed. */
11296 DECL_TEMPLATE_INSTANTIATED (d) = 0;
11300 /* This is done in analogous to `start_decl'. It is
11301 required for correct access checking. */
11302 push_nested_class (DECL_CONTEXT (d));
11304 (!DECL_INITIALIZED_IN_CLASS_P (d)
11305 ? DECL_INITIAL (d) : NULL_TREE),
11307 /* Normally, pop_nested_class is called by cp_finish_decl
11308 above. But when instantiate_decl is triggered during
11309 instantiate_class_template processing, its DECL_CONTEXT
11310 is still not completed yet, and pop_nested_class isn't
11312 if (!COMPLETE_TYPE_P (DECL_CONTEXT (d)))
11313 pop_nested_class ();
11315 /* We're not deferring instantiation any more. */
11316 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
11318 else if (TREE_CODE (d) == FUNCTION_DECL)
11320 htab_t saved_local_specializations;
11325 /* Mark D as instantiated so that recursive calls to
11326 instantiate_decl do not try to instantiate it again. */
11327 DECL_TEMPLATE_INSTANTIATED (d) = 1;
11329 /* Save away the current list, in case we are instantiating one
11330 template from within the body of another. */
11331 saved_local_specializations = local_specializations;
11333 /* Set up the list of local specializations. */
11334 local_specializations = htab_create (37,
11335 hash_local_specialization,
11336 eq_local_specializations,
11339 /* Set up context. */
11340 import_export_decl (d);
11341 start_function (NULL_TREE, d, NULL_TREE, SF_PRE_PARSED);
11343 /* Create substitution entries for the parameters. */
11344 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
11345 tmpl_parm = DECL_ARGUMENTS (subst_decl);
11346 spec_parm = DECL_ARGUMENTS (d);
11347 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
11349 register_local_specialization (spec_parm, tmpl_parm);
11350 spec_parm = skip_artificial_parms_for (d, spec_parm);
11351 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
11355 register_local_specialization (spec_parm, tmpl_parm);
11356 tmpl_parm = TREE_CHAIN (tmpl_parm);
11357 spec_parm = TREE_CHAIN (spec_parm);
11359 my_friendly_assert (!spec_parm, 20020813);
11361 /* Substitute into the body of the function. */
11362 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
11363 tf_error | tf_warning, tmpl);
11365 /* We don't need the local specializations any more. */
11366 htab_delete (local_specializations);
11367 local_specializations = saved_local_specializations;
11369 /* We're not deferring instantiation any more. */
11370 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
11372 /* Finish the function. */
11373 d = finish_function (0);
11374 expand_or_defer_fn (d);
11378 pop_from_top_level ();
11381 input_location = saved_loc;
11382 pop_deferring_access_checks ();
11383 pop_tinst_level ();
11385 timevar_pop (TV_PARSE);
11390 /* Run through the list of templates that we wish we could
11391 instantiate, and instantiate any we can. */
11394 instantiate_pending_templates (void)
11397 tree last = NULL_TREE;
11398 int instantiated_something = 0;
11400 location_t saved_loc = input_location;
11406 t = &pending_templates;
11409 tree instantiation = TREE_VALUE (*t);
11411 reopen_tinst_level (TREE_PURPOSE (*t));
11413 if (TYPE_P (instantiation))
11417 if (!COMPLETE_TYPE_P (instantiation))
11419 instantiate_class_template (instantiation);
11420 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
11421 for (fn = TYPE_METHODS (instantiation);
11423 fn = TREE_CHAIN (fn))
11424 if (! DECL_ARTIFICIAL (fn))
11425 instantiate_decl (fn, /*defer_ok=*/0);
11426 if (COMPLETE_TYPE_P (instantiation))
11428 instantiated_something = 1;
11433 if (COMPLETE_TYPE_P (instantiation))
11434 /* If INSTANTIATION has been instantiated, then we don't
11435 need to consider it again in the future. */
11436 *t = TREE_CHAIN (*t);
11440 t = &TREE_CHAIN (*t);
11445 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
11446 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
11448 instantiation = instantiate_decl (instantiation,
11450 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
11452 instantiated_something = 1;
11457 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
11458 || DECL_TEMPLATE_INSTANTIATED (instantiation))
11459 /* If INSTANTIATION has been instantiated, then we don't
11460 need to consider it again in the future. */
11461 *t = TREE_CHAIN (*t);
11465 t = &TREE_CHAIN (*t);
11469 current_tinst_level = NULL_TREE;
11471 last_pending_template = last;
11473 while (reconsider);
11475 input_location = saved_loc;
11476 return instantiated_something;
11479 /* Substitute ARGVEC into T, which is a list of initializers for
11480 either base class or a non-static data member. The TREE_PURPOSEs
11481 are DECLs, and the TREE_VALUEs are the initializer values. Used by
11482 instantiate_decl. */
11485 tsubst_initializer_list (tree t, tree argvec)
11487 tree inits = NULL_TREE;
11489 for (; t; t = TREE_CHAIN (t))
11495 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_error | tf_warning,
11497 decl = expand_member_init (decl);
11498 if (decl && !DECL_P (decl))
11499 in_base_initializer = 1;
11501 init = tsubst_expr (TREE_VALUE (t), argvec, tf_error | tf_warning,
11505 else if (TREE_CODE (init) == TREE_LIST)
11506 for (val = init; val; val = TREE_CHAIN (val))
11507 TREE_VALUE (val) = convert_from_reference (TREE_VALUE (val));
11508 else if (init != void_type_node)
11509 init = convert_from_reference (init);
11511 in_base_initializer = 0;
11515 init = build_tree_list (decl, init);
11516 TREE_CHAIN (init) = inits;
11523 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
11526 set_current_access_from_decl (tree decl)
11528 if (TREE_PRIVATE (decl))
11529 current_access_specifier = access_private_node;
11530 else if (TREE_PROTECTED (decl))
11531 current_access_specifier = access_protected_node;
11533 current_access_specifier = access_public_node;
11536 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
11537 is the instantiation (which should have been created with
11538 start_enum) and ARGS are the template arguments to use. */
11541 tsubst_enum (tree tag, tree newtag, tree args)
11545 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
11550 decl = TREE_VALUE (e);
11551 /* Note that in a template enum, the TREE_VALUE is the
11552 CONST_DECL, not the corresponding INTEGER_CST. */
11553 value = tsubst_expr (DECL_INITIAL (decl),
11554 args, tf_error | tf_warning,
11557 /* Give this enumeration constant the correct access. */
11558 set_current_access_from_decl (decl);
11560 /* Actually build the enumerator itself. */
11561 build_enumerator (DECL_NAME (decl), value, newtag);
11564 finish_enum (newtag);
11565 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
11566 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
11569 /* DECL is a FUNCTION_DECL that is a template specialization. Return
11570 its type -- but without substituting the innermost set of template
11571 arguments. So, innermost set of template parameters will appear in
11575 get_mostly_instantiated_function_type (tree decl)
11583 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
11584 targs = DECL_TI_ARGS (decl);
11585 tparms = DECL_TEMPLATE_PARMS (tmpl);
11586 parm_depth = TMPL_PARMS_DEPTH (tparms);
11588 /* There should be as many levels of arguments as there are levels
11590 my_friendly_assert (parm_depth == TMPL_ARGS_DEPTH (targs), 0);
11592 fn_type = TREE_TYPE (tmpl);
11594 if (parm_depth == 1)
11595 /* No substitution is necessary. */
11602 /* Replace the innermost level of the TARGS with NULL_TREEs to
11603 let tsubst know not to substitute for those parameters. */
11604 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
11605 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
11606 SET_TMPL_ARGS_LEVEL (partial_args, i,
11607 TMPL_ARGS_LEVEL (targs, i));
11608 SET_TMPL_ARGS_LEVEL (partial_args,
11609 TMPL_ARGS_DEPTH (targs),
11610 make_tree_vec (DECL_NTPARMS (tmpl)));
11612 /* Make sure that we can see identifiers, and compute access
11613 correctly. We can just use the context of DECL for the
11614 partial substitution here. It depends only on outer template
11615 parameters, regardless of whether the innermost level is
11616 specialized or not. */
11617 push_access_scope (decl);
11619 ++processing_template_decl;
11620 /* Now, do the (partial) substitution to figure out the
11621 appropriate function type. */
11622 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
11623 --processing_template_decl;
11625 /* Substitute into the template parameters to obtain the real
11626 innermost set of parameters. This step is important if the
11627 innermost set of template parameters contains value
11628 parameters whose types depend on outer template parameters. */
11629 TREE_VEC_LENGTH (partial_args)--;
11630 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
11632 pop_access_scope (decl);
11638 /* Return truthvalue if we're processing a template different from
11639 the last one involved in diagnostics. */
11641 problematic_instantiation_changed (void)
11643 return last_template_error_tick != tinst_level_tick;
11646 /* Remember current template involved in diagnostics. */
11648 record_last_problematic_instantiation (void)
11650 last_template_error_tick = tinst_level_tick;
11654 current_instantiation (void)
11656 return current_tinst_level;
11659 /* [temp.param] Check that template non-type parm TYPE is of an allowable
11660 type. Return zero for ok, nonzero for disallowed. Issue error and
11661 warning messages under control of COMPLAIN. */
11664 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
11666 if (INTEGRAL_TYPE_P (type))
11668 else if (POINTER_TYPE_P (type))
11670 else if (TYPE_PTR_TO_MEMBER_P (type))
11672 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11674 else if (TREE_CODE (type) == TYPENAME_TYPE)
11677 if (complain & tf_error)
11678 error ("`%#T' is not a valid type for a template constant parameter",
11683 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
11684 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
11687 dependent_type_p_r (tree type)
11693 A type is dependent if it is:
11695 -- a template parameter. Template template parameters are
11696 types for us (since TYPE_P holds true for them) so we
11697 handle them here. */
11698 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
11699 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
11701 /* -- a qualified-id with a nested-name-specifier which contains a
11702 class-name that names a dependent type or whose unqualified-id
11703 names a dependent type. */
11704 if (TREE_CODE (type) == TYPENAME_TYPE)
11706 /* -- a cv-qualified type where the cv-unqualified type is
11708 type = TYPE_MAIN_VARIANT (type);
11709 /* -- a compound type constructed from any dependent type. */
11710 if (TYPE_PTR_TO_MEMBER_P (type))
11711 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
11712 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
11714 else if (TREE_CODE (type) == POINTER_TYPE
11715 || TREE_CODE (type) == REFERENCE_TYPE)
11716 return dependent_type_p (TREE_TYPE (type));
11717 else if (TREE_CODE (type) == FUNCTION_TYPE
11718 || TREE_CODE (type) == METHOD_TYPE)
11722 if (dependent_type_p (TREE_TYPE (type)))
11724 for (arg_type = TYPE_ARG_TYPES (type);
11726 arg_type = TREE_CHAIN (arg_type))
11727 if (dependent_type_p (TREE_VALUE (arg_type)))
11731 /* -- an array type constructed from any dependent type or whose
11732 size is specified by a constant expression that is
11733 value-dependent. */
11734 if (TREE_CODE (type) == ARRAY_TYPE)
11736 if (TYPE_DOMAIN (type)
11737 && ((value_dependent_expression_p
11738 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
11739 || (type_dependent_expression_p
11740 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
11742 return dependent_type_p (TREE_TYPE (type));
11745 /* -- a template-id in which either the template name is a template
11747 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
11749 /* ... or any of the template arguments is a dependent type or
11750 an expression that is type-dependent or value-dependent. */
11751 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
11752 && (any_dependent_template_arguments_p
11753 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
11756 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
11757 expression is not type-dependent, then it should already been
11759 if (TREE_CODE (type) == TYPEOF_TYPE)
11762 /* The standard does not specifically mention types that are local
11763 to template functions or local classes, but they should be
11764 considered dependent too. For example:
11766 template <int I> void f() {
11771 The size of `E' cannot be known until the value of `I' has been
11772 determined. Therefore, `E' must be considered dependent. */
11773 scope = TYPE_CONTEXT (type);
11774 if (scope && TYPE_P (scope))
11775 return dependent_type_p (scope);
11776 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
11777 return type_dependent_expression_p (scope);
11779 /* Other types are non-dependent. */
11783 /* Returns TRUE if TYPE is dependent, in the sense of
11784 [temp.dep.type]. */
11787 dependent_type_p (tree type)
11789 /* If there are no template parameters in scope, then there can't be
11790 any dependent types. */
11791 if (!processing_template_decl)
11794 /* If the type is NULL, we have not computed a type for the entity
11795 in question; in that case, the type is dependent. */
11799 /* Erroneous types can be considered non-dependent. */
11800 if (type == error_mark_node)
11803 /* If we have not already computed the appropriate value for TYPE,
11805 if (!TYPE_DEPENDENT_P_VALID (type))
11807 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
11808 TYPE_DEPENDENT_P_VALID (type) = 1;
11811 return TYPE_DEPENDENT_P (type);
11814 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
11817 dependent_scope_ref_p (tree expression, bool criterion (tree))
11822 my_friendly_assert (TREE_CODE (expression) == SCOPE_REF, 20030714);
11824 if (!TYPE_P (TREE_OPERAND (expression, 0)))
11827 scope = TREE_OPERAND (expression, 0);
11828 name = TREE_OPERAND (expression, 1);
11832 An id-expression is type-dependent if it contains a
11833 nested-name-specifier that contains a class-name that names a
11835 /* The suggested resolution to Core Issue 2 implies that if the
11836 qualifying type is the current class, then we must peek
11839 && currently_open_class (scope)
11840 && !criterion (name))
11842 if (dependent_type_p (scope))
11848 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
11849 [temp.dep.constexpr] */
11852 value_dependent_expression_p (tree expression)
11854 if (!processing_template_decl)
11857 /* A name declared with a dependent type. */
11858 if (TREE_CODE (expression) == IDENTIFIER_NODE
11859 || (DECL_P (expression)
11860 && type_dependent_expression_p (expression)))
11862 /* A non-type template parameter. */
11863 if ((TREE_CODE (expression) == CONST_DECL
11864 && DECL_TEMPLATE_PARM_P (expression))
11865 || TREE_CODE (expression) == TEMPLATE_PARM_INDEX)
11867 /* A constant with integral or enumeration type and is initialized
11868 with an expression that is value-dependent. */
11869 if (TREE_CODE (expression) == VAR_DECL
11870 && DECL_INITIAL (expression)
11871 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
11872 && value_dependent_expression_p (DECL_INITIAL (expression)))
11874 /* These expressions are value-dependent if the type to which the
11875 cast occurs is dependent or the expression being casted is
11876 value-dependent. */
11877 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
11878 || TREE_CODE (expression) == STATIC_CAST_EXPR
11879 || TREE_CODE (expression) == CONST_CAST_EXPR
11880 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
11881 || TREE_CODE (expression) == CAST_EXPR)
11883 tree type = TREE_TYPE (expression);
11884 if (dependent_type_p (type))
11886 /* A functional cast has a list of operands. */
11887 expression = TREE_OPERAND (expression, 0);
11890 /* If there are no operands, it must be an expression such
11891 as "int()". This should not happen for aggregate types
11892 because it would form non-constant expressions. */
11893 my_friendly_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type),
11898 if (TREE_CODE (expression) == TREE_LIST)
11902 if (value_dependent_expression_p (TREE_VALUE (expression)))
11904 expression = TREE_CHAIN (expression);
11906 while (expression);
11910 return value_dependent_expression_p (expression);
11912 /* A `sizeof' expression is value-dependent if the operand is
11914 if (TREE_CODE (expression) == SIZEOF_EXPR
11915 || TREE_CODE (expression) == ALIGNOF_EXPR)
11917 expression = TREE_OPERAND (expression, 0);
11918 if (TYPE_P (expression))
11919 return dependent_type_p (expression);
11920 return type_dependent_expression_p (expression);
11922 if (TREE_CODE (expression) == SCOPE_REF)
11923 return dependent_scope_ref_p (expression, value_dependent_expression_p);
11924 if (TREE_CODE (expression) == COMPONENT_REF)
11925 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
11926 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
11927 /* A constant expression is value-dependent if any subexpression is
11928 value-dependent. */
11929 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expression))))
11931 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
11934 return (value_dependent_expression_p
11935 (TREE_OPERAND (expression, 0)));
11938 return ((value_dependent_expression_p
11939 (TREE_OPERAND (expression, 0)))
11940 || (value_dependent_expression_p
11941 (TREE_OPERAND (expression, 1))));
11945 for (i = 0; i < first_rtl_op (TREE_CODE (expression)); ++i)
11946 /* In some cases, some of the operands may be missing.
11947 (For example, in the case of PREDECREMENT_EXPR, the
11948 amount to increment by may be missing.) That doesn't
11949 make the expression dependent. */
11950 if (TREE_OPERAND (expression, i)
11951 && (value_dependent_expression_p
11952 (TREE_OPERAND (expression, i))))
11959 /* The expression is not value-dependent. */
11963 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
11964 [temp.dep.expr]. */
11967 type_dependent_expression_p (tree expression)
11969 if (!processing_template_decl)
11972 if (expression == error_mark_node)
11975 /* An unresolved name is always dependent. */
11976 if (TREE_CODE (expression) == IDENTIFIER_NODE)
11979 /* Some expression forms are never type-dependent. */
11980 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
11981 || TREE_CODE (expression) == SIZEOF_EXPR
11982 || TREE_CODE (expression) == ALIGNOF_EXPR
11983 || TREE_CODE (expression) == TYPEID_EXPR
11984 || TREE_CODE (expression) == DELETE_EXPR
11985 || TREE_CODE (expression) == VEC_DELETE_EXPR
11986 || TREE_CODE (expression) == THROW_EXPR)
11989 /* The types of these expressions depends only on the type to which
11990 the cast occurs. */
11991 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
11992 || TREE_CODE (expression) == STATIC_CAST_EXPR
11993 || TREE_CODE (expression) == CONST_CAST_EXPR
11994 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
11995 || TREE_CODE (expression) == CAST_EXPR)
11996 return dependent_type_p (TREE_TYPE (expression));
11998 /* The types of these expressions depends only on the type created
11999 by the expression. */
12000 if (TREE_CODE (expression) == NEW_EXPR
12001 || TREE_CODE (expression) == VEC_NEW_EXPR)
12003 /* For NEW_EXPR tree nodes created inside a template, either
12004 the object type itself or a TREE_LIST may appear as the
12006 tree type = TREE_OPERAND (expression, 1);
12007 if (TREE_CODE (type) == TREE_LIST)
12008 /* This is an array type. We need to check array dimensions
12010 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
12011 || value_dependent_expression_p
12012 (TREE_OPERAND (TREE_VALUE (type), 1));
12014 return dependent_type_p (type);
12017 if (TREE_CODE (expression) == SCOPE_REF
12018 && dependent_scope_ref_p (expression,
12019 type_dependent_expression_p))
12022 if (TREE_CODE (expression) == FUNCTION_DECL
12023 && DECL_LANG_SPECIFIC (expression)
12024 && DECL_TEMPLATE_INFO (expression)
12025 && (any_dependent_template_arguments_p
12026 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
12029 if (TREE_CODE (expression) == TEMPLATE_DECL
12030 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
12033 if (TREE_TYPE (expression) == unknown_type_node)
12035 if (TREE_CODE (expression) == ADDR_EXPR)
12036 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
12037 if (TREE_CODE (expression) == COMPONENT_REF
12038 || TREE_CODE (expression) == OFFSET_REF)
12040 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
12042 expression = TREE_OPERAND (expression, 1);
12043 if (TREE_CODE (expression) == IDENTIFIER_NODE)
12046 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
12047 if (TREE_CODE (expression) == SCOPE_REF)
12050 if (TREE_CODE (expression) == BASELINK)
12051 expression = BASELINK_FUNCTIONS (expression);
12052 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
12054 if (any_dependent_template_arguments_p
12055 (TREE_OPERAND (expression, 1)))
12057 expression = TREE_OPERAND (expression, 0);
12059 if (TREE_CODE (expression) == OVERLOAD
12060 || TREE_CODE (expression) == FUNCTION_DECL)
12064 if (type_dependent_expression_p (OVL_CURRENT (expression)))
12066 expression = OVL_NEXT (expression);
12073 my_friendly_assert (TREE_CODE (expression) != TYPE_DECL, 20051116);
12075 return (dependent_type_p (TREE_TYPE (expression)));
12078 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
12079 contains a type-dependent expression. */
12082 any_type_dependent_arguments_p (tree args)
12086 tree arg = TREE_VALUE (args);
12088 if (type_dependent_expression_p (arg))
12090 args = TREE_CHAIN (args);
12095 /* Returns TRUE if the ARG (a template argument) is dependent. */
12098 dependent_template_arg_p (tree arg)
12100 if (!processing_template_decl)
12103 if (TREE_CODE (arg) == TEMPLATE_DECL
12104 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12105 return dependent_template_p (arg);
12106 else if (TYPE_P (arg))
12107 return dependent_type_p (arg);
12109 return (type_dependent_expression_p (arg)
12110 || value_dependent_expression_p (arg));
12113 /* Returns true if ARGS (a collection of template arguments) contains
12114 any dependent arguments. */
12117 any_dependent_template_arguments_p (tree args)
12125 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
12127 tree level = TMPL_ARGS_LEVEL (args, i + 1);
12128 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
12129 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
12136 /* Returns TRUE if the template TMPL is dependent. */
12139 dependent_template_p (tree tmpl)
12141 if (TREE_CODE (tmpl) == OVERLOAD)
12145 if (dependent_template_p (OVL_FUNCTION (tmpl)))
12147 tmpl = OVL_CHAIN (tmpl);
12152 /* Template template parameters are dependent. */
12153 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
12154 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
12156 /* So arenames that have not been looked up. */
12157 if (TREE_CODE (tmpl) == SCOPE_REF
12158 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
12160 /* So are member templates of dependent classes. */
12161 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
12162 return dependent_type_p (DECL_CONTEXT (tmpl));
12166 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
12169 dependent_template_id_p (tree tmpl, tree args)
12171 return (dependent_template_p (tmpl)
12172 || any_dependent_template_arguments_p (args));
12175 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
12176 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
12177 can be found. Note that this function peers inside uninstantiated
12178 templates and therefore should be used only in extremely limited
12182 resolve_typename_type (tree type, bool only_current_p)
12190 my_friendly_assert (TREE_CODE (type) == TYPENAME_TYPE,
12193 scope = TYPE_CONTEXT (type);
12194 name = TYPE_IDENTIFIER (type);
12196 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
12197 it first before we can figure out what NAME refers to. */
12198 if (TREE_CODE (scope) == TYPENAME_TYPE)
12199 scope = resolve_typename_type (scope, only_current_p);
12200 /* If we don't know what SCOPE refers to, then we cannot resolve the
12202 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
12203 return error_mark_node;
12204 /* If the SCOPE is a template type parameter, we have no way of
12205 resolving the name. */
12206 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
12208 /* If the SCOPE is not the current instantiation, there's no reason
12209 to look inside it. */
12210 if (only_current_p && !currently_open_class (scope))
12211 return error_mark_node;
12212 /* If SCOPE is a partial instantiation, it will not have a valid
12213 TYPE_FIELDS list, so use the original template. */
12214 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
12215 /* Enter the SCOPE so that name lookup will be resolved as if we
12216 were in the class definition. In particular, SCOPE will no
12217 longer be considered a dependent type. */
12218 pop_p = push_scope (scope);
12219 /* Look up the declaration. */
12220 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
12221 /* Obtain the set of qualifiers applied to the TYPE. */
12222 quals = cp_type_quals (type);
12223 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
12224 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
12226 type = error_mark_node;
12227 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
12228 && TREE_CODE (decl) == TYPE_DECL)
12229 type = TREE_TYPE (decl);
12230 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
12231 && DECL_CLASS_TEMPLATE_P (decl))
12235 /* Obtain the template and the arguments. */
12236 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
12237 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
12238 /* Instantiate the template. */
12239 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
12240 /*entering_scope=*/0, tf_error | tf_user);
12243 type = error_mark_node;
12244 /* Qualify the resulting type. */
12245 if (type != error_mark_node && quals)
12246 type = cp_build_qualified_type (type, quals);
12247 /* Leave the SCOPE. */
12254 /* EXPR is an expression which is not type-dependent. Return a proxy
12255 for EXPR that can be used to compute the types of larger
12256 expressions containing EXPR. */
12259 build_non_dependent_expr (tree expr)
12263 /* Preserve null pointer constants so that the type of things like
12264 "p == 0" where "p" is a pointer can be determined. */
12265 if (null_ptr_cst_p (expr))
12267 /* Preserve OVERLOADs; the functions must be available to resolve
12269 inner_expr = (TREE_CODE (expr) == ADDR_EXPR ?
12270 TREE_OPERAND (expr, 0) : expr);
12271 if (TREE_CODE (inner_expr) == OVERLOAD
12272 || TREE_CODE (inner_expr) == FUNCTION_DECL
12273 || TREE_CODE (inner_expr) == TEMPLATE_DECL
12274 || TREE_CODE (inner_expr) == TEMPLATE_ID_EXPR
12275 || TREE_CODE (inner_expr) == OFFSET_REF)
12277 /* Preserve string constants; conversions from string constants to
12278 "char *" are allowed, even though normally a "const char *"
12279 cannot be used to initialize a "char *". */
12280 if (TREE_CODE (expr) == STRING_CST)
12282 /* Preserve arithmetic constants, as an optimization -- there is no
12283 reason to create a new node. */
12284 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
12286 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
12287 There is at least one place where we want to know that a
12288 particular expression is a throw-expression: when checking a ?:
12289 expression, there are special rules if the second or third
12290 argument is a throw-expresion. */
12291 if (TREE_CODE (expr) == THROW_EXPR)
12294 if (TREE_CODE (expr) == COND_EXPR)
12295 return build (COND_EXPR,
12297 TREE_OPERAND (expr, 0),
12298 (TREE_OPERAND (expr, 1)
12299 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
12300 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
12301 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
12302 if (TREE_CODE (expr) == COMPOUND_EXPR
12303 && !COMPOUND_EXPR_OVERLOADED (expr))
12304 return build (COMPOUND_EXPR,
12306 TREE_OPERAND (expr, 0),
12307 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
12309 /* Otherwise, build a NON_DEPENDENT_EXPR.
12311 REFERENCE_TYPEs are not stripped for expressions in templates
12312 because doing so would play havoc with mangling. Consider, for
12315 template <typename T> void f<T& g>() { g(); }
12317 In the body of "f", the expression for "g" will have
12318 REFERENCE_TYPE, even though the standard says that it should
12319 not. The reason is that we must preserve the syntactic form of
12320 the expression so that mangling (say) "f<g>" inside the body of
12321 "f" works out correctly. Therefore, the REFERENCE_TYPE is
12323 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
12326 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
12327 Return a new TREE_LIST with the various arguments replaced with
12328 equivalent non-dependent expressions. */
12331 build_non_dependent_args (tree args)
12336 new_args = NULL_TREE;
12337 for (a = args; a; a = TREE_CHAIN (a))
12338 new_args = tree_cons (NULL_TREE,
12339 build_non_dependent_expr (TREE_VALUE (a)),
12341 return nreverse (new_args);
12344 #include "gt-cp-pt.h"