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)
747 /* TYPE maybe an ERROR_MARK_NODE. */
748 tree context = TYPE_P (type) ? TYPE_CONTEXT (type) : NULL_TREE;
750 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
752 /* This is for ordinary explicit specialization and partial
753 specialization of a template class such as:
755 template <> class C<int>;
759 template <class T> class C<T*>;
761 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
763 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
764 && !COMPLETE_TYPE_P (type))
766 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
767 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
768 if (processing_template_decl)
769 push_template_decl (TYPE_MAIN_DECL (type));
771 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
772 error ("specialization of `%T' after instantiation", type);
774 else if (CLASS_TYPE_P (type)
775 && !CLASSTYPE_USE_TEMPLATE (type)
776 && CLASSTYPE_TEMPLATE_INFO (type)
777 && context && CLASS_TYPE_P (context)
778 && CLASSTYPE_TEMPLATE_INFO (context))
780 /* This is for an explicit specialization of member class
781 template according to [temp.expl.spec/18]:
783 template <> template <class U> class C<int>::D;
785 The context `C<int>' must be an implicit instantiation.
786 Otherwise this is just a member class template declared
789 template <> class C<int> { template <class U> class D; };
790 template <> template <class U> class C<int>::D;
792 In the first case, `C<int>::D' is a specialization of `C<T>::D'
793 while in the second case, `C<int>::D' is a primary template
794 and `C<T>::D' may not exist. */
796 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
797 && !COMPLETE_TYPE_P (type))
801 if (current_namespace
802 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
804 pedwarn ("specializing `%#T' in different namespace", type);
805 cp_pedwarn_at (" from definition of `%#D'",
806 CLASSTYPE_TI_TEMPLATE (type));
809 /* Check for invalid specialization after instantiation:
811 template <> template <> class C<int>::D<int>;
812 template <> template <class U> class C<int>::D; */
814 for (t = DECL_TEMPLATE_INSTANTIATIONS
815 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
816 t; t = TREE_CHAIN (t))
817 if (TREE_VALUE (t) != type
818 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
819 error ("specialization `%T' after instantiation `%T'",
820 type, TREE_VALUE (t));
822 /* Mark TYPE as a specialization. And as a result, we only
823 have one level of template argument for the innermost
825 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
826 CLASSTYPE_TI_ARGS (type)
827 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
830 else if (processing_specialization)
831 error ("explicit specialization of non-template `%T'", type);
834 /* Retrieve the specialization (in the sense of [temp.spec] - a
835 specialization is either an instantiation or an explicit
836 specialization) of TMPL for the given template ARGS. If there is
837 no such specialization, return NULL_TREE. The ARGS are a vector of
838 arguments, or a vector of vectors of arguments, in the case of
839 templates with more than one level of parameters. */
842 retrieve_specialization (tree tmpl, tree args)
846 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
848 /* There should be as many levels of arguments as there are
849 levels of parameters. */
850 my_friendly_assert (TMPL_ARGS_DEPTH (args)
851 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)),
854 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
857 if (comp_template_args (TREE_PURPOSE (s), args))
858 return TREE_VALUE (s);
863 /* Like retrieve_specialization, but for local declarations. */
866 retrieve_local_specialization (tree tmpl)
868 tree spec = htab_find_with_hash (local_specializations, tmpl,
869 htab_hash_pointer (tmpl));
870 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
873 /* Returns nonzero iff DECL is a specialization of TMPL. */
876 is_specialization_of (tree decl, tree tmpl)
880 if (TREE_CODE (decl) == FUNCTION_DECL)
884 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
890 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 0);
892 for (t = TREE_TYPE (decl);
894 t = CLASSTYPE_USE_TEMPLATE (t)
895 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
896 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
903 /* Returns nonzero iff DECL is a specialization of friend declaration
904 FRIEND according to [temp.friend]. */
907 is_specialization_of_friend (tree decl, tree friend)
909 bool need_template = true;
912 my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0);
914 /* For [temp.friend/6] when FRIEND is an ordinary member function
915 of a template class, we want to check if DECL is a specialization
917 if (TREE_CODE (friend) == FUNCTION_DECL
918 && DECL_TEMPLATE_INFO (friend)
919 && !DECL_USE_TEMPLATE (friend))
921 friend = DECL_TI_TEMPLATE (friend);
922 need_template = false;
925 /* There is nothing to do if this is not a template friend. */
926 if (TREE_CODE (friend) != TEMPLATE_DECL)
929 if (is_specialization_of (decl, friend))
933 A member of a class template may be declared to be a friend of a
934 non-template class. In this case, the corresponding member of
935 every specialization of the class template is a friend of the
936 class granting friendship.
938 For example, given a template friend declaration
940 template <class T> friend void A<T>::f();
942 the member function below is considered a friend
944 template <> struct A<int> {
948 For this type of template friend, TEMPLATE_DEPTH below will be
949 nonzero. To determine if DECL is a friend of FRIEND, we first
950 check if the enclosing class is a specialization of another. */
952 template_depth = template_class_depth (DECL_CONTEXT (friend));
954 && DECL_CLASS_SCOPE_P (decl)
955 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
956 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
958 /* Next, we check the members themselves. In order to handle
959 a few tricky cases like
961 template <class T> friend void A<T>::g(T t);
962 template <class T> template <T t> friend void A<T>::h();
964 we need to figure out what ARGS is (corresponding to `T' in above
965 examples) from DECL for later processing. */
967 tree context = DECL_CONTEXT (decl);
968 tree args = NULL_TREE;
969 int current_depth = 0;
970 while (current_depth < template_depth)
972 if (CLASSTYPE_TEMPLATE_INFO (context))
974 if (current_depth == 0)
975 args = TYPE_TI_ARGS (context);
977 args = add_to_template_args (TYPE_TI_ARGS (context), args);
980 context = TYPE_CONTEXT (context);
983 if (TREE_CODE (decl) == FUNCTION_DECL)
988 tree friend_args_type;
991 /* Make sure that both DECL and FRIEND are templates or
993 is_template = DECL_TEMPLATE_INFO (decl)
994 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
995 if (need_template ^ is_template)
997 else if (is_template)
999 /* If both are templates, check template parameter list. */
1001 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1003 if (!comp_template_parms
1004 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1008 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1011 decl_type = TREE_TYPE (decl);
1013 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1014 tf_none, NULL_TREE);
1015 if (friend_type == error_mark_node)
1018 /* Check if return types match. */
1019 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1022 /* Check if function parameter types match, ignoring the
1023 `this' parameter. */
1024 friend_args_type = TYPE_ARG_TYPES (friend_type);
1025 decl_args_type = TYPE_ARG_TYPES (decl_type);
1026 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1027 friend_args_type = TREE_CHAIN (friend_args_type);
1028 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1029 decl_args_type = TREE_CHAIN (decl_args_type);
1030 if (compparms (decl_args_type, friend_args_type))
1037 /* Register the specialization SPEC as a specialization of TMPL with
1038 the indicated ARGS. Returns SPEC, or an equivalent prior
1039 declaration, if available. */
1042 register_specialization (tree spec, tree tmpl, tree args)
1046 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
1048 if (TREE_CODE (spec) == FUNCTION_DECL
1049 && uses_template_parms (DECL_TI_ARGS (spec)))
1050 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1051 register it; we want the corresponding TEMPLATE_DECL instead.
1052 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1053 the more obvious `uses_template_parms (spec)' to avoid problems
1054 with default function arguments. In particular, given
1055 something like this:
1057 template <class T> void f(T t1, T t = T())
1059 the default argument expression is not substituted for in an
1060 instantiation unless and until it is actually needed. */
1063 /* There should be as many levels of arguments as there are
1064 levels of parameters. */
1065 my_friendly_assert (TMPL_ARGS_DEPTH (args)
1066 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)),
1069 for (s = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1073 tree fn = TREE_VALUE (s);
1075 /* We can sometimes try to re-register a specialization that we've
1076 already got. In particular, regenerate_decl_from_template
1077 calls duplicate_decls which will update the specialization
1078 list. But, we'll still get called again here anyhow. It's
1079 more convenient to simply allow this than to try to prevent it. */
1082 else if (comp_template_args (TREE_PURPOSE (s), args))
1084 if (DECL_TEMPLATE_SPECIALIZATION (spec))
1086 if (DECL_TEMPLATE_INSTANTIATION (fn))
1089 || DECL_EXPLICIT_INSTANTIATION (fn))
1091 error ("specialization of %D after instantiation",
1097 /* This situation should occur only if the first
1098 specialization is an implicit instantiation,
1099 the second is an explicit specialization, and
1100 the implicit instantiation has not yet been
1101 used. That situation can occur if we have
1102 implicitly instantiated a member function and
1103 then specialized it later.
1105 We can also wind up here if a friend
1106 declaration that looked like an instantiation
1107 turns out to be a specialization:
1109 template <class T> void foo(T);
1110 class S { friend void foo<>(int) };
1111 template <> void foo(int);
1113 We transform the existing DECL in place so that
1114 any pointers to it become pointers to the
1115 updated declaration.
1117 If there was a definition for the template, but
1118 not for the specialization, we want this to
1119 look as if there is no definition, and vice
1121 DECL_INITIAL (fn) = NULL_TREE;
1122 duplicate_decls (spec, fn);
1127 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1129 if (!duplicate_decls (spec, fn) && DECL_INITIAL (spec))
1130 /* Dup decl failed, but this is a new
1131 definition. Set the line number so any errors
1132 match this new definition. */
1133 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1141 /* A specialization must be declared in the same namespace as the
1142 template it is specializing. */
1143 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1144 && !check_specialization_namespace (tmpl))
1145 DECL_CONTEXT (spec) = decl_namespace_context (tmpl);
1147 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1148 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1153 /* Unregister the specialization SPEC as a specialization of TMPL.
1154 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1155 if the SPEC was listed as a specialization of TMPL. */
1158 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1162 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1164 s = &TREE_CHAIN (*s))
1165 if (TREE_VALUE (*s) == spec)
1168 *s = TREE_CHAIN (*s);
1170 TREE_VALUE (*s) = new_spec;
1177 /* Compare an entry in the local specializations hash table P1 (which
1178 is really a pointer to a TREE_LIST) with P2 (which is really a
1182 eq_local_specializations (const void *p1, const void *p2)
1184 return TREE_VALUE ((tree) p1) == (tree) p2;
1187 /* Hash P1, an entry in the local specializations table. */
1190 hash_local_specialization (const void* p1)
1192 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1195 /* Like register_specialization, but for local declarations. We are
1196 registering SPEC, an instantiation of TMPL. */
1199 register_local_specialization (tree spec, tree tmpl)
1203 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1204 htab_hash_pointer (tmpl), INSERT);
1205 *slot = build_tree_list (spec, tmpl);
1208 /* Print the list of candidate FNS in an error message. */
1211 print_candidates (tree fns)
1215 const char *str = "candidates are:";
1217 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1221 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1222 cp_error_at ("%s %+#D", str, OVL_CURRENT (f));
1227 /* Returns the template (one of the functions given by TEMPLATE_ID)
1228 which can be specialized to match the indicated DECL with the
1229 explicit template args given in TEMPLATE_ID. The DECL may be
1230 NULL_TREE if none is available. In that case, the functions in
1231 TEMPLATE_ID are non-members.
1233 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1234 specialization of a member template.
1236 The template args (those explicitly specified and those deduced)
1237 are output in a newly created vector *TARGS_OUT.
1239 If it is impossible to determine the result, an error message is
1240 issued. The error_mark_node is returned to indicate failure. */
1243 determine_specialization (tree template_id,
1246 int need_member_template)
1250 tree explicit_targs;
1251 tree candidates = NULL_TREE;
1252 tree templates = NULL_TREE;
1254 *targs_out = NULL_TREE;
1256 if (template_id == error_mark_node)
1257 return error_mark_node;
1259 fns = TREE_OPERAND (template_id, 0);
1260 explicit_targs = TREE_OPERAND (template_id, 1);
1262 if (fns == error_mark_node)
1263 return error_mark_node;
1265 /* Check for baselinks. */
1266 if (BASELINK_P (fns))
1267 fns = BASELINK_FUNCTIONS (fns);
1269 if (!is_overloaded_fn (fns))
1271 error ("`%D' is not a function template", fns);
1272 return error_mark_node;
1275 for (; fns; fns = OVL_NEXT (fns))
1277 tree fn = OVL_CURRENT (fns);
1279 if (TREE_CODE (fn) == TEMPLATE_DECL)
1281 tree decl_arg_types;
1284 /* DECL might be a specialization of FN. */
1286 /* Adjust the type of DECL in case FN is a static member. */
1287 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1288 if (DECL_STATIC_FUNCTION_P (fn)
1289 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1290 decl_arg_types = TREE_CHAIN (decl_arg_types);
1292 /* Check that the number of function parameters matches.
1294 template <class T> void f(int i = 0);
1295 template <> void f<int>();
1296 The specialization f<int> is invalid but is not caught
1297 by get_bindings below. */
1299 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1300 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1303 /* For a non-static member function, we need to make sure that
1304 the const qualification is the same. This can be done by
1305 checking the 'this' in the argument list. */
1306 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1307 && !same_type_p (TREE_VALUE (fn_arg_types),
1308 TREE_VALUE (decl_arg_types)))
1311 /* See whether this function might be a specialization of this
1313 targs = get_bindings (fn, decl, explicit_targs);
1316 /* We cannot deduce template arguments that when used to
1317 specialize TMPL will produce DECL. */
1320 /* Save this template, and the arguments deduced. */
1321 templates = tree_cons (targs, fn, templates);
1323 else if (need_member_template)
1324 /* FN is an ordinary member function, and we need a
1325 specialization of a member template. */
1327 else if (TREE_CODE (fn) != FUNCTION_DECL)
1328 /* We can get IDENTIFIER_NODEs here in certain erroneous
1331 else if (!DECL_FUNCTION_MEMBER_P (fn))
1332 /* This is just an ordinary non-member function. Nothing can
1333 be a specialization of that. */
1335 else if (DECL_ARTIFICIAL (fn))
1336 /* Cannot specialize functions that are created implicitly. */
1340 tree decl_arg_types;
1342 /* This is an ordinary member function. However, since
1343 we're here, we can assume it's enclosing class is a
1344 template class. For example,
1346 template <typename T> struct S { void f(); };
1347 template <> void S<int>::f() {}
1349 Here, S<int>::f is a non-template, but S<int> is a
1350 template class. If FN has the same type as DECL, we
1351 might be in business. */
1353 if (!DECL_TEMPLATE_INFO (fn))
1354 /* Its enclosing class is an explicit specialization
1355 of a template class. This is not a candidate. */
1358 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1359 TREE_TYPE (TREE_TYPE (fn))))
1360 /* The return types differ. */
1363 /* Adjust the type of DECL in case FN is a static member. */
1364 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1365 if (DECL_STATIC_FUNCTION_P (fn)
1366 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1367 decl_arg_types = TREE_CHAIN (decl_arg_types);
1369 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1372 candidates = tree_cons (NULL_TREE, fn, candidates);
1376 if (templates && TREE_CHAIN (templates))
1382 It is possible for a specialization with a given function
1383 signature to be instantiated from more than one function
1384 template. In such cases, explicit specification of the
1385 template arguments must be used to uniquely identify the
1386 function template specialization being specialized.
1388 Note that here, there's no suggestion that we're supposed to
1389 determine which of the candidate templates is most
1390 specialized. However, we, also have:
1394 Partial ordering of overloaded function template
1395 declarations is used in the following contexts to select
1396 the function template to which a function template
1397 specialization refers:
1399 -- when an explicit specialization refers to a function
1402 So, we do use the partial ordering rules, at least for now.
1403 This extension can only serve to make invalid programs valid,
1404 so it's safe. And, there is strong anecdotal evidence that
1405 the committee intended the partial ordering rules to apply;
1406 the EDG front-end has that behavior, and John Spicer claims
1407 that the committee simply forgot to delete the wording in
1408 [temp.expl.spec]. */
1409 tree tmpl = most_specialized (templates, decl, explicit_targs);
1410 if (tmpl && tmpl != error_mark_node)
1412 targs = get_bindings (tmpl, decl, explicit_targs);
1413 templates = tree_cons (targs, tmpl, NULL_TREE);
1417 if (templates == NULL_TREE && candidates == NULL_TREE)
1419 cp_error_at ("template-id `%D' for `%+D' does not match any template declaration",
1421 return error_mark_node;
1423 else if ((templates && TREE_CHAIN (templates))
1424 || (candidates && TREE_CHAIN (candidates))
1425 || (templates && candidates))
1427 cp_error_at ("ambiguous template specialization `%D' for `%+D'",
1429 chainon (candidates, templates);
1430 print_candidates (candidates);
1431 return error_mark_node;
1434 /* We have one, and exactly one, match. */
1437 /* It was a specialization of an ordinary member function in a
1439 *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates)));
1440 return DECL_TI_TEMPLATE (TREE_VALUE (candidates));
1443 /* It was a specialization of a template. */
1444 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1445 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1447 *targs_out = copy_node (targs);
1448 SET_TMPL_ARGS_LEVEL (*targs_out,
1449 TMPL_ARGS_DEPTH (*targs_out),
1450 TREE_PURPOSE (templates));
1453 *targs_out = TREE_PURPOSE (templates);
1454 return TREE_VALUE (templates);
1457 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1458 but with the default argument values filled in from those in the
1462 copy_default_args_to_explicit_spec_1 (tree spec_types,
1465 tree new_spec_types;
1470 if (spec_types == void_list_node)
1471 return void_list_node;
1473 /* Substitute into the rest of the list. */
1475 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1476 TREE_CHAIN (tmpl_types));
1478 /* Add the default argument for this parameter. */
1479 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1480 TREE_VALUE (spec_types),
1484 /* DECL is an explicit specialization. Replicate default arguments
1485 from the template it specializes. (That way, code like:
1487 template <class T> void f(T = 3);
1488 template <> void f(double);
1491 works, as required.) An alternative approach would be to look up
1492 the correct default arguments at the call-site, but this approach
1493 is consistent with how implicit instantiations are handled. */
1496 copy_default_args_to_explicit_spec (tree decl)
1501 tree new_spec_types;
1505 tree object_type = NULL_TREE;
1506 tree in_charge = NULL_TREE;
1507 tree vtt = NULL_TREE;
1509 /* See if there's anything we need to do. */
1510 tmpl = DECL_TI_TEMPLATE (decl);
1511 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1512 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1513 if (TREE_PURPOSE (t))
1518 old_type = TREE_TYPE (decl);
1519 spec_types = TYPE_ARG_TYPES (old_type);
1521 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1523 /* Remove the this pointer, but remember the object's type for
1525 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1526 spec_types = TREE_CHAIN (spec_types);
1527 tmpl_types = TREE_CHAIN (tmpl_types);
1529 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1531 /* DECL may contain more parameters than TMPL due to the extra
1532 in-charge parameter in constructors and destructors. */
1533 in_charge = spec_types;
1534 spec_types = TREE_CHAIN (spec_types);
1536 if (DECL_HAS_VTT_PARM_P (decl))
1539 spec_types = TREE_CHAIN (spec_types);
1543 /* Compute the merged default arguments. */
1545 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1547 /* Compute the new FUNCTION_TYPE. */
1551 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1556 /* Put the in-charge parameter back. */
1557 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1558 TREE_VALUE (in_charge),
1561 new_type = build_method_type_directly (object_type,
1562 TREE_TYPE (old_type),
1566 new_type = build_function_type (TREE_TYPE (old_type),
1568 new_type = cp_build_type_attribute_variant (new_type,
1569 TYPE_ATTRIBUTES (old_type));
1570 new_type = build_exception_variant (new_type,
1571 TYPE_RAISES_EXCEPTIONS (old_type));
1572 TREE_TYPE (decl) = new_type;
1575 /* Check to see if the function just declared, as indicated in
1576 DECLARATOR, and in DECL, is a specialization of a function
1577 template. We may also discover that the declaration is an explicit
1578 instantiation at this point.
1580 Returns DECL, or an equivalent declaration that should be used
1581 instead if all goes well. Issues an error message if something is
1582 amiss. Returns error_mark_node if the error is not easily
1585 FLAGS is a bitmask consisting of the following flags:
1587 2: The function has a definition.
1588 4: The function is a friend.
1590 The TEMPLATE_COUNT is the number of references to qualifying
1591 template classes that appeared in the name of the function. For
1594 template <class T> struct S { void f(); };
1597 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1598 classes are not counted in the TEMPLATE_COUNT, so that in
1600 template <class T> struct S {};
1601 template <> struct S<int> { void f(); }
1602 template <> void S<int>::f();
1604 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1605 invalid; there should be no template <>.)
1607 If the function is a specialization, it is marked as such via
1608 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1609 is set up correctly, and it is added to the list of specializations
1610 for that template. */
1613 check_explicit_specialization (tree declarator,
1618 int have_def = flags & 2;
1619 int is_friend = flags & 4;
1620 int specialization = 0;
1621 int explicit_instantiation = 0;
1622 int member_specialization = 0;
1623 tree ctype = DECL_CLASS_CONTEXT (decl);
1624 tree dname = DECL_NAME (decl);
1627 tsk = current_tmpl_spec_kind (template_count);
1632 if (processing_specialization)
1635 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1637 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1640 /* This could be something like:
1642 template <class T> void f(T);
1643 class S { friend void f<>(int); } */
1647 /* This case handles bogus declarations like template <>
1648 template <class T> void f<int>(); */
1650 error ("template-id `%D' in declaration of primary template",
1657 case tsk_invalid_member_spec:
1658 /* The error has already been reported in
1659 check_specialization_scope. */
1660 return error_mark_node;
1662 case tsk_invalid_expl_inst:
1663 error ("template parameter list used in explicit instantiation");
1669 error ("definition provided for explicit instantiation");
1671 explicit_instantiation = 1;
1674 case tsk_excessive_parms:
1675 error ("too many template parameter lists in declaration of `%D'",
1677 return error_mark_node;
1681 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1683 member_specialization = 1;
1688 case tsk_insufficient_parms:
1689 if (template_header_count)
1691 error("too few template parameter lists in declaration of `%D'",
1695 else if (ctype != NULL_TREE
1696 && !TYPE_BEING_DEFINED (ctype)
1697 && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype)
1700 /* For backwards compatibility, we accept:
1702 template <class T> struct S { void f(); };
1703 void S<int>::f() {} // Missing template <>
1705 That used to be valid C++. */
1708 ("explicit specialization not preceded by `template <>'");
1710 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1715 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1717 /* This case handles bogus declarations like template <>
1718 template <class T> void f<int>(); */
1720 if (uses_template_parms (declarator))
1721 error ("partial specialization `%D' of function template",
1724 error ("template-id `%D' in declaration of primary template",
1729 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1730 /* This is a specialization of a member template, without
1731 specialization the containing class. Something like:
1733 template <class T> struct S {
1734 template <class U> void f (U);
1736 template <> template <class U> void S<int>::f(U) {}
1738 That's a specialization -- but of the entire template. */
1746 if (specialization || member_specialization)
1748 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1749 for (; t; t = TREE_CHAIN (t))
1750 if (TREE_PURPOSE (t))
1753 ("default argument specified in explicit specialization");
1756 if (current_lang_name == lang_name_c)
1757 error ("template specialization with C linkage");
1760 if (specialization || member_specialization || explicit_instantiation)
1762 tree tmpl = NULL_TREE;
1763 tree targs = NULL_TREE;
1765 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1766 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1770 my_friendly_assert (TREE_CODE (declarator) == IDENTIFIER_NODE, 0);
1775 /* If there is no class context, the explicit instantiation
1776 must be at namespace scope. */
1777 my_friendly_assert (DECL_NAMESPACE_SCOPE_P (decl), 20030625);
1779 /* Find the namespace binding, using the declaration
1781 fns = namespace_binding (dname, CP_DECL_CONTEXT (decl));
1782 if (!fns || !is_overloaded_fn (fns))
1784 error ("`%D' is not a template function", dname);
1785 fns = error_mark_node;
1789 declarator = lookup_template_function (fns, NULL_TREE);
1792 if (declarator == error_mark_node)
1793 return error_mark_node;
1795 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1797 if (!explicit_instantiation)
1798 /* A specialization in class scope. This is invalid,
1799 but the error will already have been flagged by
1800 check_specialization_scope. */
1801 return error_mark_node;
1804 /* It's not valid to write an explicit instantiation in
1807 class C { template void f(); }
1809 This case is caught by the parser. However, on
1812 template class C { void f(); };
1814 (which is invalid) we can get here. The error will be
1821 else if (ctype != NULL_TREE
1822 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
1825 /* Find the list of functions in ctype that have the same
1826 name as the declared function. */
1827 tree name = TREE_OPERAND (declarator, 0);
1828 tree fns = NULL_TREE;
1831 if (constructor_name_p (name, ctype))
1833 int is_constructor = DECL_CONSTRUCTOR_P (decl);
1835 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
1836 : !TYPE_HAS_DESTRUCTOR (ctype))
1838 /* From [temp.expl.spec]:
1840 If such an explicit specialization for the member
1841 of a class template names an implicitly-declared
1842 special member function (clause _special_), the
1843 program is ill-formed.
1845 Similar language is found in [temp.explicit]. */
1846 error ("specialization of implicitly-declared special member function");
1847 return error_mark_node;
1850 name = is_constructor ? ctor_identifier : dtor_identifier;
1853 if (!DECL_CONV_FN_P (decl))
1855 idx = lookup_fnfields_1 (ctype, name);
1857 fns = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (ctype), idx);
1863 /* For a type-conversion operator, we cannot do a
1864 name-based lookup. We might be looking for `operator
1865 int' which will be a specialization of `operator T'.
1866 So, we find *all* the conversion operators, and then
1867 select from them. */
1870 methods = CLASSTYPE_METHOD_VEC (ctype);
1872 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
1873 idx < TREE_VEC_LENGTH (methods); ++idx)
1875 tree ovl = TREE_VEC_ELT (methods, idx);
1877 if (!ovl || !DECL_CONV_FN_P (OVL_CURRENT (ovl)))
1878 /* There are no more conversion functions. */
1881 /* Glue all these conversion functions together
1882 with those we already have. */
1883 for (; ovl; ovl = OVL_NEXT (ovl))
1884 fns = ovl_cons (OVL_CURRENT (ovl), fns);
1888 if (fns == NULL_TREE)
1890 error ("no member function `%D' declared in `%T'",
1892 return error_mark_node;
1895 TREE_OPERAND (declarator, 0) = fns;
1898 /* Figure out what exactly is being specialized at this point.
1899 Note that for an explicit instantiation, even one for a
1900 member function, we cannot tell apriori whether the
1901 instantiation is for a member template, or just a member
1902 function of a template class. Even if a member template is
1903 being instantiated, the member template arguments may be
1904 elided if they can be deduced from the rest of the
1906 tmpl = determine_specialization (declarator, decl,
1908 member_specialization);
1910 if (!tmpl || tmpl == error_mark_node)
1911 /* We couldn't figure out what this declaration was
1913 return error_mark_node;
1916 tree gen_tmpl = most_general_template (tmpl);
1918 if (explicit_instantiation)
1920 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
1921 is done by do_decl_instantiation later. */
1923 int arg_depth = TMPL_ARGS_DEPTH (targs);
1924 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
1926 if (arg_depth > parm_depth)
1928 /* If TMPL is not the most general template (for
1929 example, if TMPL is a friend template that is
1930 injected into namespace scope), then there will
1931 be too many levels of TARGS. Remove some of them
1936 new_targs = make_tree_vec (parm_depth);
1937 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
1938 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
1939 = TREE_VEC_ELT (targs, i);
1943 return instantiate_template (tmpl, targs, tf_error);
1946 /* If we thought that the DECL was a member function, but it
1947 turns out to be specializing a static member function,
1948 make DECL a static member function as well. */
1949 if (DECL_STATIC_FUNCTION_P (tmpl)
1950 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1951 revert_static_member_fn (decl);
1953 /* If this is a specialization of a member template of a
1954 template class. In we want to return the TEMPLATE_DECL,
1955 not the specialization of it. */
1956 if (tsk == tsk_template)
1958 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
1959 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
1962 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
1963 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
1964 = DECL_SOURCE_LOCATION (decl);
1965 /* We want to use the argument list specified in the
1966 definition, not in the original declaration. */
1967 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
1968 = DECL_ARGUMENTS (decl);
1973 /* Set up the DECL_TEMPLATE_INFO for DECL. */
1974 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
1976 /* Inherit default function arguments from the template
1977 DECL is specializing. */
1978 copy_default_args_to_explicit_spec (decl);
1980 /* This specialization has the same protection as the
1981 template it specializes. */
1982 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
1983 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
1985 if (is_friend && !have_def)
1986 /* This is not really a declaration of a specialization.
1987 It's just the name of an instantiation. But, it's not
1988 a request for an instantiation, either. */
1989 SET_DECL_IMPLICIT_INSTANTIATION (decl);
1990 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
1991 /* This is indeed a specialization. In case of constructors
1992 and destructors, we need in-charge and not-in-charge
1993 versions in V3 ABI. */
1994 clone_function_decl (decl, /*update_method_vec_p=*/0);
1996 /* Register this specialization so that we can find it
1998 decl = register_specialization (decl, gen_tmpl, targs);
2005 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2006 parameters. These are represented in the same format used for
2007 DECL_TEMPLATE_PARMS. */
2009 int comp_template_parms (tree parms1, tree parms2)
2014 if (parms1 == parms2)
2017 for (p1 = parms1, p2 = parms2;
2018 p1 != NULL_TREE && p2 != NULL_TREE;
2019 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2021 tree t1 = TREE_VALUE (p1);
2022 tree t2 = TREE_VALUE (p2);
2025 my_friendly_assert (TREE_CODE (t1) == TREE_VEC, 0);
2026 my_friendly_assert (TREE_CODE (t2) == TREE_VEC, 0);
2028 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2031 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2033 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2034 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2036 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2039 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2041 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2046 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2047 /* One set of parameters has more parameters lists than the
2054 /* Complain if DECL shadows a template parameter.
2056 [temp.local]: A template-parameter shall not be redeclared within its
2057 scope (including nested scopes). */
2060 check_template_shadow (tree decl)
2064 /* If we're not in a template, we can't possibly shadow a template
2066 if (!current_template_parms)
2069 /* Figure out what we're shadowing. */
2070 if (TREE_CODE (decl) == OVERLOAD)
2071 decl = OVL_CURRENT (decl);
2072 olddecl = IDENTIFIER_VALUE (DECL_NAME (decl));
2074 /* If there's no previous binding for this name, we're not shadowing
2075 anything, let alone a template parameter. */
2079 /* If we're not shadowing a template parameter, we're done. Note
2080 that OLDDECL might be an OVERLOAD (or perhaps even an
2081 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2083 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2086 /* We check for decl != olddecl to avoid bogus errors for using a
2087 name inside a class. We check TPFI to avoid duplicate errors for
2088 inline member templates. */
2090 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2093 cp_error_at ("declaration of `%#D'", decl);
2094 cp_error_at (" shadows template parm `%#D'", olddecl);
2097 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2098 ORIG_LEVEL, DECL, and TYPE. */
2101 build_template_parm_index (int index,
2107 tree t = make_node (TEMPLATE_PARM_INDEX);
2108 TEMPLATE_PARM_IDX (t) = index;
2109 TEMPLATE_PARM_LEVEL (t) = level;
2110 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2111 TEMPLATE_PARM_DECL (t) = decl;
2112 TREE_TYPE (t) = type;
2113 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2114 TREE_READONLY (t) = TREE_READONLY (decl);
2119 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2120 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2121 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2122 new one is created. */
2125 reduce_template_parm_level (tree index, tree type, int levels)
2127 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2128 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2129 != TEMPLATE_PARM_LEVEL (index) - levels))
2131 tree orig_decl = TEMPLATE_PARM_DECL (index);
2134 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2135 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2136 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2137 DECL_ARTIFICIAL (decl) = 1;
2138 SET_DECL_TEMPLATE_PARM_P (decl);
2140 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2141 TEMPLATE_PARM_LEVEL (index) - levels,
2142 TEMPLATE_PARM_ORIG_LEVEL (index),
2144 TEMPLATE_PARM_DESCENDANTS (index) = t;
2146 /* Template template parameters need this. */
2147 DECL_TEMPLATE_PARMS (decl)
2148 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2151 return TEMPLATE_PARM_DESCENDANTS (index);
2154 /* Process information from new template parameter NEXT and append it to the
2155 LIST being built. */
2158 process_template_parm (tree list, tree next)
2166 my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259);
2167 defval = TREE_PURPOSE (parm);
2168 parm = TREE_VALUE (parm);
2169 is_type = TREE_PURPOSE (parm) == class_type_node;
2173 tree p = TREE_VALUE (tree_last (list));
2175 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2176 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2178 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2186 my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260);
2187 /* is a const-param */
2188 parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm),
2190 SET_DECL_TEMPLATE_PARM_P (parm);
2194 The top-level cv-qualifiers on the template-parameter are
2195 ignored when determining its type. */
2196 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2198 /* A template parameter is not modifiable. */
2199 TREE_READONLY (parm) = TREE_CONSTANT (parm) = 1;
2200 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2201 TREE_TYPE (parm) = void_type_node;
2202 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2203 TREE_CONSTANT (decl) = TREE_READONLY (decl) = 1;
2204 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2205 = build_template_parm_index (idx, processing_template_decl,
2206 processing_template_decl,
2207 decl, TREE_TYPE (parm));
2212 parm = TREE_VALUE (parm);
2214 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2216 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2217 /* This is for distinguishing between real templates and template
2218 template parameters */
2219 TREE_TYPE (parm) = t;
2220 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2225 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2226 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2227 decl = build_decl (TYPE_DECL, parm, t);
2230 TYPE_NAME (t) = decl;
2231 TYPE_STUB_DECL (t) = decl;
2233 TEMPLATE_TYPE_PARM_INDEX (t)
2234 = build_template_parm_index (idx, processing_template_decl,
2235 processing_template_decl,
2236 decl, TREE_TYPE (parm));
2238 DECL_ARTIFICIAL (decl) = 1;
2239 SET_DECL_TEMPLATE_PARM_P (decl);
2241 parm = build_tree_list (defval, parm);
2242 return chainon (list, parm);
2245 /* The end of a template parameter list has been reached. Process the
2246 tree list into a parameter vector, converting each parameter into a more
2247 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2251 end_template_parm_list (tree parms)
2255 tree saved_parmlist = make_tree_vec (list_length (parms));
2257 current_template_parms
2258 = tree_cons (size_int (processing_template_decl),
2259 saved_parmlist, current_template_parms);
2261 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2263 next = TREE_CHAIN (parm);
2264 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2265 TREE_CHAIN (parm) = NULL_TREE;
2268 --processing_template_parmlist;
2270 return saved_parmlist;
2273 /* end_template_decl is called after a template declaration is seen. */
2276 end_template_decl (void)
2278 reset_specialization ();
2280 if (! processing_template_decl)
2283 /* This matches the pushlevel in begin_template_parm_list. */
2286 --processing_template_decl;
2287 current_template_parms = TREE_CHAIN (current_template_parms);
2290 /* Given a template argument vector containing the template PARMS.
2291 The innermost PARMS are given first. */
2294 current_template_args (void)
2297 tree args = NULL_TREE;
2298 int length = TMPL_PARMS_DEPTH (current_template_parms);
2301 /* If there is only one level of template parameters, we do not
2302 create a TREE_VEC of TREE_VECs. Instead, we return a single
2303 TREE_VEC containing the arguments. */
2305 args = make_tree_vec (length);
2307 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2309 tree a = copy_node (TREE_VALUE (header));
2312 TREE_TYPE (a) = NULL_TREE;
2313 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2315 tree t = TREE_VEC_ELT (a, i);
2317 /* T will be a list if we are called from within a
2318 begin/end_template_parm_list pair, but a vector directly
2319 if within a begin/end_member_template_processing pair. */
2320 if (TREE_CODE (t) == TREE_LIST)
2324 if (TREE_CODE (t) == TYPE_DECL
2325 || TREE_CODE (t) == TEMPLATE_DECL)
2328 t = DECL_INITIAL (t);
2329 TREE_VEC_ELT (a, i) = t;
2334 TREE_VEC_ELT (args, --l) = a;
2342 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2343 template PARMS. Used by push_template_decl below. */
2346 build_template_decl (tree decl, tree parms)
2348 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2349 DECL_TEMPLATE_PARMS (tmpl) = parms;
2350 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2351 if (DECL_LANG_SPECIFIC (decl))
2353 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2354 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2355 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2356 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2357 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2358 if (DECL_OVERLOADED_OPERATOR_P (decl))
2359 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2360 DECL_OVERLOADED_OPERATOR_P (decl));
2366 struct template_parm_data
2368 /* The level of the template parameters we are currently
2372 /* The index of the specialization argument we are currently
2376 /* An array whose size is the number of template parameters. The
2377 elements are nonzero if the parameter has been used in any one
2378 of the arguments processed so far. */
2381 /* An array whose size is the number of template arguments. The
2382 elements are nonzero if the argument makes use of template
2383 parameters of this level. */
2384 int* arg_uses_template_parms;
2387 /* Subroutine of push_template_decl used to see if each template
2388 parameter in a partial specialization is used in the explicit
2389 argument list. If T is of the LEVEL given in DATA (which is
2390 treated as a template_parm_data*), then DATA->PARMS is marked
2394 mark_template_parm (tree t, void* data)
2398 struct template_parm_data* tpd = (struct template_parm_data*) data;
2400 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2402 level = TEMPLATE_PARM_LEVEL (t);
2403 idx = TEMPLATE_PARM_IDX (t);
2407 level = TEMPLATE_TYPE_LEVEL (t);
2408 idx = TEMPLATE_TYPE_IDX (t);
2411 if (level == tpd->level)
2413 tpd->parms[idx] = 1;
2414 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2417 /* Return zero so that for_each_template_parm will continue the
2418 traversal of the tree; we want to mark *every* template parm. */
2422 /* Process the partial specialization DECL. */
2425 process_partial_specialization (tree decl)
2427 tree type = TREE_TYPE (decl);
2428 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2429 tree specargs = CLASSTYPE_TI_ARGS (type);
2430 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2431 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2432 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2433 int nargs = TREE_VEC_LENGTH (inner_args);
2434 int ntparms = TREE_VEC_LENGTH (inner_parms);
2436 int did_error_intro = 0;
2437 struct template_parm_data tpd;
2438 struct template_parm_data tpd2;
2440 /* We check that each of the template parameters given in the
2441 partial specialization is used in the argument list to the
2442 specialization. For example:
2444 template <class T> struct S;
2445 template <class T> struct S<T*>;
2447 The second declaration is OK because `T*' uses the template
2448 parameter T, whereas
2450 template <class T> struct S<int>;
2452 is no good. Even trickier is:
2463 The S2<T> declaration is actually invalid; it is a
2464 full-specialization. Of course,
2467 struct S2<T (*)(U)>;
2469 or some such would have been OK. */
2470 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2471 tpd.parms = alloca (sizeof (int) * ntparms);
2472 memset (tpd.parms, 0, sizeof (int) * ntparms);
2474 tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
2475 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2476 for (i = 0; i < nargs; ++i)
2478 tpd.current_arg = i;
2479 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2480 &mark_template_parm,
2484 for (i = 0; i < ntparms; ++i)
2485 if (tpd.parms[i] == 0)
2487 /* One of the template parms was not used in the
2489 if (!did_error_intro)
2491 error ("template parameters not used in partial specialization:");
2492 did_error_intro = 1;
2496 TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2499 /* [temp.class.spec]
2501 The argument list of the specialization shall not be identical to
2502 the implicit argument list of the primary template. */
2503 if (comp_template_args
2505 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2507 error ("partial specialization `%T' does not specialize any template arguments", type);
2509 /* [temp.class.spec]
2511 A partially specialized non-type argument expression shall not
2512 involve template parameters of the partial specialization except
2513 when the argument expression is a simple identifier.
2515 The type of a template parameter corresponding to a specialized
2516 non-type argument shall not be dependent on a parameter of the
2518 my_friendly_assert (nargs == DECL_NTPARMS (maintmpl), 0);
2520 for (i = 0; i < nargs; ++i)
2522 tree arg = TREE_VEC_ELT (inner_args, i);
2523 if (/* These first two lines are the `non-type' bit. */
2525 && TREE_CODE (arg) != TEMPLATE_DECL
2526 /* This next line is the `argument expression is not just a
2527 simple identifier' condition and also the `specialized
2528 non-type argument' bit. */
2529 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2531 if (tpd.arg_uses_template_parms[i])
2532 error ("template argument `%E' involves template parameter(s)", arg);
2535 /* Look at the corresponding template parameter,
2536 marking which template parameters its type depends
2539 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2544 /* We haven't yet initialized TPD2. Do so now. */
2545 tpd2.arg_uses_template_parms
2546 = alloca (sizeof (int) * nargs);
2547 /* The number of parameters here is the number in the
2548 main template, which, as checked in the assertion
2550 tpd2.parms = alloca (sizeof (int) * nargs);
2552 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2555 /* Mark the template parameters. But this time, we're
2556 looking for the template parameters of the main
2557 template, not in the specialization. */
2558 tpd2.current_arg = i;
2559 tpd2.arg_uses_template_parms[i] = 0;
2560 memset (tpd2.parms, 0, sizeof (int) * nargs);
2561 for_each_template_parm (type,
2562 &mark_template_parm,
2566 if (tpd2.arg_uses_template_parms [i])
2568 /* The type depended on some template parameters.
2569 If they are fully specialized in the
2570 specialization, that's OK. */
2572 for (j = 0; j < nargs; ++j)
2573 if (tpd2.parms[j] != 0
2574 && tpd.arg_uses_template_parms [j])
2576 error ("type `%T' of template argument `%E' depends on template parameter(s)",
2586 if (retrieve_specialization (maintmpl, specargs))
2587 /* We've already got this specialization. */
2590 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2591 = tree_cons (inner_args, inner_parms,
2592 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2593 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2597 /* Check that a template declaration's use of default arguments is not
2598 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2599 nonzero if DECL is the thing declared by a primary template.
2600 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2603 check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2606 int last_level_to_check;
2611 A default template-argument shall not be specified in a
2612 function template declaration or a function template definition, nor
2613 in the template-parameter-list of the definition of a member of a
2616 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2617 /* You can't have a function template declaration in a local
2618 scope, nor you can you define a member of a class template in a
2622 if (current_class_type
2623 && !TYPE_BEING_DEFINED (current_class_type)
2624 && DECL_LANG_SPECIFIC (decl)
2625 /* If this is either a friend defined in the scope of the class
2626 or a member function. */
2627 && (DECL_FUNCTION_MEMBER_P (decl)
2628 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2629 : DECL_FRIEND_CONTEXT (decl)
2630 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2632 /* And, if it was a member function, it really was defined in
2633 the scope of the class. */
2634 && (!DECL_FUNCTION_MEMBER_P (decl)
2635 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2636 /* We already checked these parameters when the template was
2637 declared, so there's no need to do it again now. This function
2638 was defined in class scope, but we're processing it's body now
2639 that the class is complete. */
2644 If a template-parameter has a default template-argument, all
2645 subsequent template-parameters shall have a default
2646 template-argument supplied. */
2647 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2649 tree inner_parms = TREE_VALUE (parm_level);
2650 int ntparms = TREE_VEC_LENGTH (inner_parms);
2651 int seen_def_arg_p = 0;
2654 for (i = 0; i < ntparms; ++i)
2656 tree parm = TREE_VEC_ELT (inner_parms, i);
2657 if (TREE_PURPOSE (parm))
2659 else if (seen_def_arg_p)
2661 error ("no default argument for `%D'", TREE_VALUE (parm));
2662 /* For better subsequent error-recovery, we indicate that
2663 there should have been a default argument. */
2664 TREE_PURPOSE (parm) = error_mark_node;
2669 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2670 /* For an ordinary class template, default template arguments are
2671 allowed at the innermost level, e.g.:
2672 template <class T = int>
2674 but, in a partial specialization, they're not allowed even
2675 there, as we have in [temp.class.spec]:
2677 The template parameter list of a specialization shall not
2678 contain default template argument values.
2680 So, for a partial specialization, or for a function template,
2681 we look at all of them. */
2684 /* But, for a primary class template that is not a partial
2685 specialization we look at all template parameters except the
2687 parms = TREE_CHAIN (parms);
2689 /* Figure out what error message to issue. */
2690 if (TREE_CODE (decl) == FUNCTION_DECL)
2691 msg = "default template arguments may not be used in function templates";
2692 else if (is_partial)
2693 msg = "default template arguments may not be used in partial specializations";
2695 msg = "default argument for template parameter for class enclosing `%D'";
2697 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2698 /* If we're inside a class definition, there's no need to
2699 examine the parameters to the class itself. On the one
2700 hand, they will be checked when the class is defined, and,
2701 on the other, default arguments are valid in things like:
2702 template <class T = double>
2703 struct S { template <class U> void f(U); };
2704 Here the default argument for `S' has no bearing on the
2705 declaration of `f'. */
2706 last_level_to_check = template_class_depth (current_class_type) + 1;
2708 /* Check everything. */
2709 last_level_to_check = 0;
2711 for (parm_level = parms;
2712 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2713 parm_level = TREE_CHAIN (parm_level))
2715 tree inner_parms = TREE_VALUE (parm_level);
2719 ntparms = TREE_VEC_LENGTH (inner_parms);
2720 for (i = 0; i < ntparms; ++i)
2721 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2729 /* Clear out the default argument so that we are not
2731 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2734 /* At this point, if we're still interested in issuing messages,
2735 they must apply to classes surrounding the object declared. */
2737 msg = "default argument for template parameter for class enclosing `%D'";
2741 /* Worker for push_template_decl_real, called via
2742 for_each_template_parm. DATA is really an int, indicating the
2743 level of the parameters we are interested in. If T is a template
2744 parameter of that level, return nonzero. */
2747 template_parm_this_level_p (tree t, void* data)
2749 int this_level = *(int *)data;
2752 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2753 level = TEMPLATE_PARM_LEVEL (t);
2755 level = TEMPLATE_TYPE_LEVEL (t);
2756 return level == this_level;
2759 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2760 parameters given by current_template_args, or reuses a
2761 previously existing one, if appropriate. Returns the DECL, or an
2762 equivalent one, if it is replaced via a call to duplicate_decls.
2764 If IS_FRIEND is nonzero, DECL is a friend declaration. */
2767 push_template_decl_real (tree decl, int is_friend)
2775 int new_template_p = 0;
2777 /* See if this is a partial specialization. */
2778 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
2779 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
2780 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
2782 is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl));
2785 /* For a friend, we want the context of the friend function, not
2786 the type of which it is a friend. */
2787 ctx = DECL_CONTEXT (decl);
2788 else if (CP_DECL_CONTEXT (decl)
2789 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
2790 /* In the case of a virtual function, we want the class in which
2792 ctx = CP_DECL_CONTEXT (decl);
2794 /* Otherwise, if we're currently defining some class, the DECL
2795 is assumed to be a member of the class. */
2796 ctx = current_scope ();
2798 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
2801 if (!DECL_CONTEXT (decl))
2802 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2804 /* See if this is a primary template. */
2805 primary = template_parm_scope_p ();
2809 if (current_lang_name == lang_name_c)
2810 error ("template with C linkage");
2811 else if (TREE_CODE (decl) == TYPE_DECL
2812 && ANON_AGGRNAME_P (DECL_NAME (decl)))
2813 error ("template class without a name");
2814 else if (TREE_CODE (decl) == FUNCTION_DECL)
2816 if (DECL_DESTRUCTOR_P (decl))
2820 A destructor shall not be a member template. */
2821 error ("destructor `%D' declared as member template", decl);
2822 return error_mark_node;
2824 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
2825 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
2826 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
2827 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
2828 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
2829 == void_list_node)))
2831 /* [basic.stc.dynamic.allocation]
2833 An allocation function can be a function
2834 template. ... Template allocation functions shall
2835 have two or more parameters. */
2836 error ("invalid template declaration of `%D'", decl);
2840 else if ((DECL_IMPLICIT_TYPEDEF_P (decl)
2841 && CLASS_TYPE_P (TREE_TYPE (decl)))
2842 || (TREE_CODE (decl) == VAR_DECL && ctx && CLASS_TYPE_P (ctx)))
2846 error ("template declaration of `%#D'", decl);
2847 return error_mark_node;
2851 /* Check to see that the rules regarding the use of default
2852 arguments are not being violated. */
2853 check_default_tmpl_args (decl, current_template_parms,
2854 primary, is_partial);
2857 return process_partial_specialization (decl);
2859 args = current_template_args ();
2862 || TREE_CODE (ctx) == FUNCTION_DECL
2863 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
2864 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
2866 if (DECL_LANG_SPECIFIC (decl)
2867 && DECL_TEMPLATE_INFO (decl)
2868 && DECL_TI_TEMPLATE (decl))
2869 tmpl = DECL_TI_TEMPLATE (decl);
2870 /* If DECL is a TYPE_DECL for a class-template, then there won't
2871 be DECL_LANG_SPECIFIC. The information equivalent to
2872 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2873 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
2874 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2875 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2877 /* Since a template declaration already existed for this
2878 class-type, we must be redeclaring it here. Make sure
2879 that the redeclaration is valid. */
2880 redeclare_class_template (TREE_TYPE (decl),
2881 current_template_parms);
2882 /* We don't need to create a new TEMPLATE_DECL; just use the
2883 one we already had. */
2884 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
2888 tmpl = build_template_decl (decl, current_template_parms);
2891 if (DECL_LANG_SPECIFIC (decl)
2892 && DECL_TEMPLATE_SPECIALIZATION (decl))
2894 /* A specialization of a member template of a template
2896 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2897 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
2898 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
2904 tree a, t, current, parms;
2907 if (TREE_CODE (decl) == TYPE_DECL)
2909 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
2910 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2911 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2912 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2913 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
2916 error ("`%D' does not declare a template type", decl);
2920 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
2922 error ("template definition of non-template `%#D'", decl);
2926 tmpl = DECL_TI_TEMPLATE (decl);
2928 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
2929 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
2930 && DECL_TEMPLATE_SPECIALIZATION (decl)
2931 && is_member_template (tmpl))
2935 /* The declaration is a specialization of a member
2936 template, declared outside the class. Therefore, the
2937 innermost template arguments will be NULL, so we
2938 replace them with the arguments determined by the
2939 earlier call to check_explicit_specialization. */
2940 args = DECL_TI_ARGS (decl);
2943 = build_template_decl (decl, current_template_parms);
2944 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
2945 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
2946 DECL_TI_TEMPLATE (decl) = new_tmpl;
2947 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
2948 DECL_TEMPLATE_INFO (new_tmpl)
2949 = tree_cons (tmpl, args, NULL_TREE);
2951 register_specialization (new_tmpl,
2952 most_general_template (tmpl),
2957 /* Make sure the template headers we got make sense. */
2959 parms = DECL_TEMPLATE_PARMS (tmpl);
2960 i = TMPL_PARMS_DEPTH (parms);
2961 if (TMPL_ARGS_DEPTH (args) != i)
2963 error ("expected %d levels of template parms for `%#D', got %d",
2964 i, decl, TMPL_ARGS_DEPTH (args));
2967 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
2969 a = TMPL_ARGS_LEVEL (args, i);
2970 t = INNERMOST_TEMPLATE_PARMS (parms);
2972 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
2974 if (current == decl)
2975 error ("got %d template parameters for `%#D'",
2976 TREE_VEC_LENGTH (a), decl);
2978 error ("got %d template parameters for `%#T'",
2979 TREE_VEC_LENGTH (a), current);
2980 error (" but %d required", TREE_VEC_LENGTH (t));
2983 /* Perhaps we should also check that the parms are used in the
2984 appropriate qualifying scopes in the declarator? */
2986 if (current == decl)
2989 current = TYPE_CONTEXT (current);
2993 DECL_TEMPLATE_RESULT (tmpl) = decl;
2994 TREE_TYPE (tmpl) = TREE_TYPE (decl);
2996 /* Push template declarations for global functions and types. Note
2997 that we do not try to push a global template friend declared in a
2998 template class; such a thing may well depend on the template
2999 parameters of the class. */
3000 if (new_template_p && !ctx
3001 && !(is_friend && template_class_depth (current_class_type) > 0))
3002 tmpl = pushdecl_namespace_level (tmpl);
3006 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3007 if (DECL_CONV_FN_P (tmpl))
3009 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3011 /* It is a conversion operator. See if the type converted to
3012 depends on innermost template operands. */
3014 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3016 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3020 /* The DECL_TI_ARGS of DECL contains full set of arguments refering
3021 back to its most general template. If TMPL is a specialization,
3022 ARGS may only have the innermost set of arguments. Add the missing
3023 argument levels if necessary. */
3024 if (DECL_TEMPLATE_INFO (tmpl))
3025 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3027 info = tree_cons (tmpl, args, NULL_TREE);
3029 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3031 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3032 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
3033 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3034 /* Don't change the name if we've already set it up. */
3035 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
3036 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
3038 else if (DECL_LANG_SPECIFIC (decl))
3039 DECL_TEMPLATE_INFO (decl) = info;
3041 return DECL_TEMPLATE_RESULT (tmpl);
3045 push_template_decl (tree decl)
3047 return push_template_decl_real (decl, 0);
3050 /* Called when a class template TYPE is redeclared with the indicated
3051 template PARMS, e.g.:
3053 template <class T> struct S;
3054 template <class T> struct S {}; */
3057 redeclare_class_template (tree type, tree parms)
3063 if (!TYPE_TEMPLATE_INFO (type))
3065 error ("`%T' is not a template type", type);
3069 tmpl = TYPE_TI_TEMPLATE (type);
3070 if (!PRIMARY_TEMPLATE_P (tmpl))
3071 /* The type is nested in some template class. Nothing to worry
3072 about here; there are no new template parameters for the nested
3076 parms = INNERMOST_TEMPLATE_PARMS (parms);
3077 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3079 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3081 cp_error_at ("previous declaration `%D'", tmpl);
3082 error ("used %d template parameter(s) instead of %d",
3083 TREE_VEC_LENGTH (tmpl_parms),
3084 TREE_VEC_LENGTH (parms));
3088 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3090 tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3091 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3092 tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3093 tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3095 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm))
3097 cp_error_at ("template parameter `%#D'", tmpl_parm);
3098 error ("redeclared here as `%#D'", parm);
3102 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3104 /* We have in [temp.param]:
3106 A template-parameter may not be given default arguments
3107 by two different declarations in the same scope. */
3108 error ("redefinition of default argument for `%#D'", parm);
3109 error ("%J original definition appeared here", tmpl_parm);
3113 if (parm_default != NULL_TREE)
3114 /* Update the previous template parameters (which are the ones
3115 that will really count) with the new default value. */
3116 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3117 else if (tmpl_default != NULL_TREE)
3118 /* Update the new parameters, too; they'll be used as the
3119 parameters for any members. */
3120 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3124 /* Simplify EXPR if it is a non-dependent expression. Returns the
3125 (possibly simplified) expression. */
3128 fold_non_dependent_expr (tree expr)
3130 /* If we're in a template, but EXPR isn't value dependent, simplify
3131 it. We're supposed to treat:
3133 template <typename T> void f(T[1 + 1]);
3134 template <typename T> void f(T[2]);
3136 as two declarations of the same function, for example. */
3137 if (processing_template_decl
3138 && !type_dependent_expression_p (expr)
3139 && !value_dependent_expression_p (expr))
3141 HOST_WIDE_INT saved_processing_template_decl;
3143 saved_processing_template_decl = processing_template_decl;
3144 processing_template_decl = 0;
3145 expr = tsubst_copy_and_build (expr,
3148 /*in_decl=*/NULL_TREE,
3149 /*function_p=*/false);
3150 processing_template_decl = saved_processing_template_decl;
3155 /* Attempt to convert the non-type template parameter EXPR to the
3156 indicated TYPE. If the conversion is successful, return the
3157 converted value. If the conversion is unsuccessful, return
3158 NULL_TREE if we issued an error message, or error_mark_node if we
3159 did not. We issue error messages for out-and-out bad template
3160 parameters, but not simply because the conversion failed, since we
3161 might be just trying to do argument deduction. Both TYPE and EXPR
3162 must be non-dependent. */
3165 convert_nontype_argument (tree type, tree expr)
3169 /* If we are in a template, EXPR may be non-dependent, but still
3170 have a syntactic, rather than semantic, form. For example, EXPR
3171 might be a SCOPE_REF, rather than the VAR_DECL to which the
3172 SCOPE_REF refers. Preserving the qualifying scope is necessary
3173 so that access checking can be performed when the template is
3174 instantiated -- but here we need the resolved form so that we can
3175 convert the argument. */
3176 expr = fold_non_dependent_expr (expr);
3177 expr_type = TREE_TYPE (expr);
3179 /* A template-argument for a non-type, non-template
3180 template-parameter shall be one of:
3182 --an integral constant-expression of integral or enumeration
3185 --the name of a non-type template-parameter; or
3187 --the name of an object or function with external linkage,
3188 including function templates and function template-ids but
3189 excluding non-static class members, expressed as id-expression;
3192 --the address of an object or function with external linkage,
3193 including function templates and function template-ids but
3194 excluding non-static class members, expressed as & id-expression
3195 where the & is optional if the name refers to a function or
3198 --a pointer to member expressed as described in _expr.unary.op_. */
3200 /* An integral constant-expression can include const variables or
3201 . enumerators. Simplify things by folding them to their values,
3202 unless we're about to bind the declaration to a reference
3204 if (INTEGRAL_TYPE_P (expr_type) && TREE_CODE (type) != REFERENCE_TYPE)
3207 tree const_expr = decl_constant_value (expr);
3208 /* In a template, the initializer for a VAR_DECL may not be
3209 marked as TREE_CONSTANT, in which case decl_constant_value
3210 will not return the initializer. Handle that special case
3212 if (expr == const_expr
3213 && DECL_INTEGRAL_CONSTANT_VAR_P (expr)
3214 /* DECL_INITIAL can be NULL if we are processing a
3215 variable initialized to an expression involving itself.
3216 We know it is initialized to a constant -- but not what
3218 && DECL_INITIAL (expr))
3219 const_expr = DECL_INITIAL (expr);
3220 if (expr == const_expr)
3222 expr = fold_non_dependent_expr (const_expr);
3225 if (is_overloaded_fn (expr))
3226 /* OK for now. We'll check that it has external linkage later.
3227 Check this first since if expr_type is the unknown_type_node
3228 we would otherwise complain below. */
3230 else if (TYPE_PTR_TO_MEMBER_P (expr_type))
3232 if (TREE_CODE (expr) != PTRMEM_CST)
3235 else if (TYPE_PTR_P (expr_type)
3236 || TREE_CODE (expr_type) == ARRAY_TYPE
3237 || TREE_CODE (type) == REFERENCE_TYPE
3238 /* If expr is the address of an overloaded function, we
3239 will get the unknown_type_node at this point. */
3240 || expr_type == unknown_type_node)
3246 if (TREE_CODE (expr_type) == ARRAY_TYPE
3247 || (TREE_CODE (type) == REFERENCE_TYPE
3248 && TREE_CODE (e) != ADDR_EXPR))
3252 if (TREE_CODE (e) != ADDR_EXPR)
3255 error ("`%E' is not a valid template argument", expr);
3256 if (TYPE_PTR_P (expr_type))
3258 if (TREE_CODE (TREE_TYPE (expr_type)) == FUNCTION_TYPE)
3259 error ("it must be the address of a function with external linkage");
3261 error ("it must be the address of an object with external linkage");
3263 else if (TYPE_PTR_TO_MEMBER_P (expr_type))
3264 error ("it must be a pointer-to-member of the form `&X::Y'");
3269 referent = TREE_OPERAND (e, 0);
3270 STRIP_NOPS (referent);
3273 if (TREE_CODE (referent) == STRING_CST)
3275 error ("string literal %E is not a valid template argument because it is the address of an object with static linkage",
3280 if (TREE_CODE (referent) == SCOPE_REF)
3281 referent = TREE_OPERAND (referent, 1);
3283 if (is_overloaded_fn (referent))
3284 /* We'll check that it has external linkage later. */
3286 else if (TREE_CODE (referent) != VAR_DECL)
3288 else if (!DECL_EXTERNAL_LINKAGE_P (referent))
3290 error ("address of non-extern `%E' cannot be used as template argument", referent);
3291 return error_mark_node;
3294 else if (INTEGRAL_TYPE_P (expr_type) || TYPE_PTR_TO_MEMBER_P (expr_type))
3296 if (! TREE_CONSTANT (expr))
3299 error ("non-constant `%E' cannot be used as template argument",
3307 error ("type '%T' cannot be used as a value for a non-type "
3308 "template-parameter", expr);
3309 else if (DECL_P (expr))
3310 error ("invalid use of '%D' as a non-type template-argument", expr);
3312 error ("invalid use of '%E' as a non-type template-argument", expr);
3317 switch (TREE_CODE (type))
3322 /* For a non-type template-parameter of integral or enumeration
3323 type, integral promotions (_conv.prom_) and integral
3324 conversions (_conv.integral_) are applied. */
3325 if (!INTEGRAL_TYPE_P (expr_type))
3326 return error_mark_node;
3328 /* It's safe to call digest_init in this case; we know we're
3329 just converting one integral constant expression to another. */
3330 expr = digest_init (type, expr, (tree*) 0);
3332 if (TREE_CODE (expr) != INTEGER_CST)
3333 /* Curiously, some TREE_CONSTANT integral expressions do not
3334 simplify to integer constants. For example, `3 % 0',
3335 remains a TRUNC_MOD_EXPR. */
3344 /* For a non-type template-parameter of type pointer to data
3345 member, qualification conversions (_conv.qual_) are
3347 e = perform_qualification_conversions (type, expr);
3348 if (TREE_CODE (e) == NOP_EXPR)
3349 /* The call to perform_qualification_conversions will
3350 insert a NOP_EXPR over EXPR to do express conversion,
3351 if necessary. But, that will confuse us if we use
3352 this (converted) template parameter to instantiate
3353 another template; then the thing will not look like a
3354 valid template argument. So, just make a new
3355 constant, of the appropriate type. */
3356 e = make_ptrmem_cst (type, PTRMEM_CST_MEMBER (expr));
3362 tree type_pointed_to = TREE_TYPE (type);
3364 if (TREE_CODE (type_pointed_to) == FUNCTION_TYPE)
3366 /* For a non-type template-parameter of type pointer to
3367 function, only the function-to-pointer conversion
3368 (_conv.func_) is applied. If the template-argument
3369 represents a set of overloaded functions (or a pointer to
3370 such), the matching function is selected from the set
3375 if (TREE_CODE (expr) == ADDR_EXPR)
3376 fns = TREE_OPERAND (expr, 0);
3380 fn = instantiate_type (type_pointed_to, fns, tf_none);
3382 if (fn == error_mark_node)
3383 return error_mark_node;
3385 if (!DECL_EXTERNAL_LINKAGE_P (fn))
3387 if (really_overloaded_fn (fns))
3388 return error_mark_node;
3393 expr = build_unary_op (ADDR_EXPR, fn, 0);
3395 my_friendly_assert (same_type_p (type, TREE_TYPE (expr)),
3401 /* For a non-type template-parameter of type pointer to
3402 object, qualification conversions (_conv.qual_) and the
3403 array-to-pointer conversion (_conv.array_) are applied.
3404 [Note: In particular, neither the null pointer conversion
3405 (_conv.ptr_) nor the derived-to-base conversion
3406 (_conv.ptr_) are applied. Although 0 is a valid
3407 template-argument for a non-type template-parameter of
3408 integral type, it is not a valid template-argument for a
3409 non-type template-parameter of pointer type.]
3411 The call to decay_conversion performs the
3412 array-to-pointer conversion, if appropriate. */
3413 expr = decay_conversion (expr);
3415 if (expr == error_mark_node)
3416 return error_mark_node;
3418 return perform_qualification_conversions (type, expr);
3423 case REFERENCE_TYPE:
3425 tree type_referred_to = TREE_TYPE (type);
3427 /* If this expression already has reference type, get the
3428 underlying object. */
3429 if (TREE_CODE (expr_type) == REFERENCE_TYPE)
3431 if (TREE_CODE (expr) == NOP_EXPR
3432 && TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR)
3434 my_friendly_assert (TREE_CODE (expr) == ADDR_EXPR, 20000604);
3435 expr = TREE_OPERAND (expr, 0);
3436 expr_type = TREE_TYPE (expr);
3439 if (TREE_CODE (type_referred_to) == FUNCTION_TYPE)
3441 /* For a non-type template-parameter of type reference to
3442 function, no conversions apply. If the
3443 template-argument represents a set of overloaded
3444 functions, the matching function is selected from the
3445 set (_over.over_). */
3448 fn = instantiate_type (type_referred_to, expr, tf_none);
3450 if (fn == error_mark_node)
3451 return error_mark_node;
3453 if (!DECL_EXTERNAL_LINKAGE_P (fn))
3455 if (really_overloaded_fn (expr))
3456 /* Don't issue an error here; we might get a different
3457 function if the overloading had worked out
3459 return error_mark_node;
3464 my_friendly_assert (same_type_p (type_referred_to,
3472 /* For a non-type template-parameter of type reference to
3473 object, no conversions apply. The type referred to by the
3474 reference may be more cv-qualified than the (otherwise
3475 identical) type of the template-argument. The
3476 template-parameter is bound directly to the
3477 template-argument, which must be an lvalue. */
3478 if (!same_type_p (TYPE_MAIN_VARIANT (expr_type),
3479 TYPE_MAIN_VARIANT (type_referred_to))
3480 || !at_least_as_qualified_p (type_referred_to,
3482 || !real_lvalue_p (expr))
3483 return error_mark_node;
3486 cxx_mark_addressable (expr);
3487 return build_nop (type, build_address (expr));
3493 my_friendly_assert (TYPE_PTRMEMFUNC_P (type), 20010112);
3495 /* For a non-type template-parameter of type pointer to member
3496 function, no conversions apply. If the template-argument
3497 represents a set of overloaded member functions, the
3498 matching member function is selected from the set
3501 if (!TYPE_PTRMEMFUNC_P (expr_type) &&
3502 expr_type != unknown_type_node)
3503 return error_mark_node;
3505 if (TREE_CODE (expr) == PTRMEM_CST)
3507 /* A ptr-to-member constant. */
3508 if (!same_type_p (type, expr_type))
3509 return error_mark_node;
3514 if (TREE_CODE (expr) != ADDR_EXPR)
3515 return error_mark_node;
3517 expr = instantiate_type (type, expr, tf_none);
3519 if (expr == error_mark_node)
3520 return error_mark_node;
3522 if (!same_type_p (type, TREE_TYPE (expr)))
3523 return error_mark_node;
3530 /* All non-type parameters must have one of these types. */
3535 return error_mark_node;
3538 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3539 template template parameters. Both PARM_PARMS and ARG_PARMS are
3540 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3543 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3544 the case, then extra parameters must have default arguments.
3546 Consider the example:
3547 template <class T, class Allocator = allocator> class vector;
3548 template<template <class U> class TT> class C;
3550 C<vector> is a valid instantiation. PARM_PARMS for the above code
3551 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3552 T and Allocator) and OUTER_ARGS contains the argument that is used to
3553 substitute the TT parameter. */
3556 coerce_template_template_parms (tree parm_parms,
3558 tsubst_flags_t complain,
3562 int nparms, nargs, i;
3565 my_friendly_assert (TREE_CODE (parm_parms) == TREE_VEC, 0);
3566 my_friendly_assert (TREE_CODE (arg_parms) == TREE_VEC, 0);
3568 nparms = TREE_VEC_LENGTH (parm_parms);
3569 nargs = TREE_VEC_LENGTH (arg_parms);
3571 /* The rule here is opposite of coerce_template_parms. */
3574 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE))
3577 for (i = 0; i < nparms; ++i)
3579 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3580 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3582 if (arg == NULL_TREE || arg == error_mark_node
3583 || parm == NULL_TREE || parm == error_mark_node)
3586 if (TREE_CODE (arg) != TREE_CODE (parm))
3589 switch (TREE_CODE (parm))
3595 /* We encounter instantiations of templates like
3596 template <template <template <class> class> class TT>
3599 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3600 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3602 if (!coerce_template_template_parms
3603 (parmparm, argparm, complain, in_decl, outer_args))
3609 /* The tsubst call is used to handle cases such as
3610 template <class T, template <T> class TT> class D;
3611 i.e. the parameter list of TT depends on earlier parameters. */
3613 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3625 /* Convert the indicated template ARG as necessary to match the
3626 indicated template PARM. Returns the converted ARG, or
3627 error_mark_node if the conversion was unsuccessful. Error and
3628 warning messages are issued under control of COMPLAIN. This
3629 conversion is for the Ith parameter in the parameter list. ARGS is
3630 the full set of template arguments deduced so far. */
3633 convert_template_argument (tree parm,
3636 tsubst_flags_t complain,
3642 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3644 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3646 if (TREE_CODE (arg) == TREE_LIST
3647 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3649 /* The template argument was the name of some
3650 member function. That's usually
3651 invalid, but static members are OK. In any
3652 case, grab the underlying fields/functions
3653 and issue an error later if required. */
3654 arg = TREE_VALUE (arg);
3655 TREE_TYPE (arg) = unknown_type_node;
3658 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3659 requires_type = (TREE_CODE (parm) == TYPE_DECL
3660 || requires_tmpl_type);
3662 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3663 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3664 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3665 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3668 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3669 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3670 arg = TYPE_STUB_DECL (arg);
3672 is_type = TYPE_P (arg) || is_tmpl_type;
3674 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3675 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3677 pedwarn ("to refer to a type member of a template parameter, use `typename %E'", arg);
3679 arg = make_typename_type (TREE_OPERAND (arg, 0),
3680 TREE_OPERAND (arg, 1),
3681 complain & tf_error);
3684 if (is_type != requires_type)
3688 if (complain & tf_error)
3690 error ("type/value mismatch at argument %d in template parameter list for `%D'",
3693 error (" expected a constant of type `%T', got `%T'",
3695 (is_tmpl_type ? DECL_NAME (arg) : arg));
3696 else if (requires_tmpl_type)
3697 error (" expected a class template, got `%E'", arg);
3699 error (" expected a type, got `%E'", arg);
3702 return error_mark_node;
3704 if (is_tmpl_type ^ requires_tmpl_type)
3706 if (in_decl && (complain & tf_error))
3708 error ("type/value mismatch at argument %d in template parameter list for `%D'",
3711 error (" expected a type, got `%T'", DECL_NAME (arg));
3713 error (" expected a class template, got `%T'", arg);
3715 return error_mark_node;
3720 if (requires_tmpl_type)
3722 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
3723 /* The number of argument required is not known yet.
3724 Just accept it for now. */
3725 val = TREE_TYPE (arg);
3728 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3729 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3731 if (coerce_template_template_parms (parmparm, argparm,
3737 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3739 if (val != error_mark_node
3740 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
3741 val = TREE_TYPE (val);
3745 if (in_decl && (complain & tf_error))
3747 error ("type/value mismatch at argument %d in template parameter list for `%D'",
3749 error (" expected a template of type `%D', got `%D'", parm, arg);
3752 val = error_mark_node;
3757 val = groktypename (arg);
3761 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
3763 if (invalid_nontype_parm_type_p (t, complain))
3764 return error_mark_node;
3766 if (!uses_template_parms (arg) && !uses_template_parms (t))
3767 /* We used to call digest_init here. However, digest_init
3768 will report errors, which we don't want when complain
3769 is zero. More importantly, digest_init will try too
3770 hard to convert things: for example, `0' should not be
3771 converted to pointer type at this point according to
3772 the standard. Accepting this is not merely an
3773 extension, since deciding whether or not these
3774 conversions can occur is part of determining which
3775 function template to call, or whether a given explicit
3776 argument specification is valid. */
3777 val = convert_nontype_argument (t, arg);
3781 if (val == NULL_TREE)
3782 val = error_mark_node;
3783 else if (val == error_mark_node && (complain & tf_error))
3784 error ("could not convert template argument `%E' to `%T'",
3791 /* Convert all template arguments to their appropriate types, and
3792 return a vector containing the innermost resulting template
3793 arguments. If any error occurs, return error_mark_node. Error and
3794 warning messages are issued under control of COMPLAIN.
3796 If REQUIRE_ALL_ARGUMENTS is nonzero, all arguments must be
3797 provided in ARGLIST, or else trailing parameters must have default
3798 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3799 deduction for any unspecified trailing arguments. */
3802 coerce_template_parms (tree parms,
3805 tsubst_flags_t complain,
3806 int require_all_arguments)
3808 int nparms, nargs, i, lost = 0;
3811 tree new_inner_args;
3813 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3814 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
3815 nparms = TREE_VEC_LENGTH (parms);
3819 && require_all_arguments
3820 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
3822 if (complain & tf_error)
3824 error ("wrong number of template arguments (%d, should be %d)",
3828 cp_error_at ("provided for `%D'", in_decl);
3831 return error_mark_node;
3834 new_inner_args = make_tree_vec (nparms);
3835 new_args = add_outermost_template_args (args, new_inner_args);
3836 for (i = 0; i < nparms; i++)
3841 /* Get the Ith template parameter. */
3842 parm = TREE_VEC_ELT (parms, i);
3844 /* Calculate the Ith argument. */
3846 arg = TREE_VEC_ELT (inner_args, i);
3847 else if (require_all_arguments)
3848 /* There must be a default arg in this case. */
3849 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
3854 my_friendly_assert (arg, 20030727);
3855 if (arg == error_mark_node)
3856 error ("template argument %d is invalid", i + 1);
3858 arg = convert_template_argument (TREE_VALUE (parm),
3859 arg, new_args, complain, i,
3862 if (arg == error_mark_node)
3864 TREE_VEC_ELT (new_inner_args, i) = arg;
3868 return error_mark_node;
3870 return new_inner_args;
3873 /* Returns 1 if template args OT and NT are equivalent. */
3876 template_args_equal (tree ot, tree nt)
3881 if (TREE_CODE (nt) == TREE_VEC)
3882 /* For member templates */
3883 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
3884 else if (TYPE_P (nt))
3885 return TYPE_P (ot) && same_type_p (ot, nt);
3886 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
3889 return cp_tree_equal (ot, nt);
3892 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
3893 of template arguments. Returns 0 otherwise. */
3896 comp_template_args (tree oldargs, tree newargs)
3900 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
3903 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
3905 tree nt = TREE_VEC_ELT (newargs, i);
3906 tree ot = TREE_VEC_ELT (oldargs, i);
3908 if (! template_args_equal (ot, nt))
3914 /* Given class template name and parameter list, produce a user-friendly name
3915 for the instantiation. */
3918 mangle_class_name_for_template (const char* name, tree parms, tree arglist)
3920 static struct obstack scratch_obstack;
3921 static char *scratch_firstobj;
3924 if (!scratch_firstobj)
3925 gcc_obstack_init (&scratch_obstack);
3927 obstack_free (&scratch_obstack, scratch_firstobj);
3928 scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
3930 #define ccat(C) obstack_1grow (&scratch_obstack, (C));
3931 #define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
3935 nparms = TREE_VEC_LENGTH (parms);
3936 arglist = INNERMOST_TEMPLATE_ARGS (arglist);
3937 my_friendly_assert (nparms == TREE_VEC_LENGTH (arglist), 268);
3938 for (i = 0; i < nparms; i++)
3940 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3941 tree arg = TREE_VEC_ELT (arglist, i);
3946 if (TREE_CODE (parm) == TYPE_DECL)
3948 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
3951 else if (TREE_CODE (parm) == TEMPLATE_DECL)
3953 if (TREE_CODE (arg) == TEMPLATE_DECL)
3955 /* Already substituted with real template. Just output
3956 the template name here */
3957 tree context = DECL_CONTEXT (arg);
3960 /* The template may be defined in a namespace, or
3961 may be a member template. */
3962 my_friendly_assert (TREE_CODE (context) == NAMESPACE_DECL
3963 || CLASS_TYPE_P (context),
3965 cat(decl_as_string (DECL_CONTEXT (arg), TFF_PLAIN_IDENTIFIER));
3968 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
3971 /* Output the parameter declaration. */
3972 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
3976 my_friendly_assert (TREE_CODE (parm) == PARM_DECL, 269);
3978 /* No need to check arglist against parmlist here; we did that
3979 in coerce_template_parms, called from lookup_template_class. */
3980 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
3983 char *bufp = obstack_next_free (&scratch_obstack);
3985 while (bufp[offset - 1] == ' ')
3987 obstack_blank_fast (&scratch_obstack, offset);
3989 /* B<C<char> >, not B<C<char>> */
3990 if (bufp[offset - 1] == '>')
3995 return (char *) obstack_base (&scratch_obstack);
3999 classtype_mangled_name (tree t)
4001 if (CLASSTYPE_TEMPLATE_INFO (t)
4002 /* Specializations have already had their names set up in
4003 lookup_template_class. */
4004 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4006 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4008 /* For non-primary templates, the template parameters are
4009 implicit from their surrounding context. */
4010 if (PRIMARY_TEMPLATE_P (tmpl))
4012 tree name = DECL_NAME (tmpl);
4013 char *mangled_name = mangle_class_name_for_template
4014 (IDENTIFIER_POINTER (name),
4015 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4016 CLASSTYPE_TI_ARGS (t));
4017 tree id = get_identifier (mangled_name);
4018 IDENTIFIER_TEMPLATE (id) = name;
4023 return TYPE_IDENTIFIER (t);
4027 add_pending_template (tree d)
4029 tree ti = (TYPE_P (d)
4030 ? CLASSTYPE_TEMPLATE_INFO (d)
4031 : DECL_TEMPLATE_INFO (d));
4035 if (TI_PENDING_TEMPLATE_FLAG (ti))
4038 /* We are called both from instantiate_decl, where we've already had a
4039 tinst_level pushed, and instantiate_template, where we haven't.
4041 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4044 push_tinst_level (d);
4046 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4047 if (last_pending_template)
4048 TREE_CHAIN (last_pending_template) = pt;
4050 pending_templates = pt;
4052 last_pending_template = pt;
4054 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4061 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4062 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4063 documentation for TEMPLATE_ID_EXPR. */
4066 lookup_template_function (tree fns, tree arglist)
4070 if (fns == error_mark_node || arglist == error_mark_node)
4071 return error_mark_node;
4073 my_friendly_assert (!arglist || TREE_CODE (arglist) == TREE_VEC, 20030726);
4074 my_friendly_assert (fns && (is_overloaded_fn (fns)
4075 || TREE_CODE (fns) == IDENTIFIER_NODE),
4078 if (BASELINK_P (fns))
4080 BASELINK_FUNCTIONS (fns) = build (TEMPLATE_ID_EXPR,
4082 BASELINK_FUNCTIONS (fns),
4087 type = TREE_TYPE (fns);
4088 if (TREE_CODE (fns) == OVERLOAD || !type)
4089 type = unknown_type_node;
4091 return build (TEMPLATE_ID_EXPR, type, fns, arglist);
4094 /* Within the scope of a template class S<T>, the name S gets bound
4095 (in build_self_reference) to a TYPE_DECL for the class, not a
4096 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4097 or one of its enclosing classes, and that type is a template,
4098 return the associated TEMPLATE_DECL. Otherwise, the original
4099 DECL is returned. */
4102 maybe_get_template_decl_from_type_decl (tree decl)
4104 return (decl != NULL_TREE
4105 && TREE_CODE (decl) == TYPE_DECL
4106 && DECL_ARTIFICIAL (decl)
4107 && CLASS_TYPE_P (TREE_TYPE (decl))
4108 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4109 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4112 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4113 parameters, find the desired type.
4115 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4117 IN_DECL, if non-NULL, is the template declaration we are trying to
4120 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4121 the class we are looking up.
4123 Issue error and warning messages under control of COMPLAIN.
4125 If the template class is really a local class in a template
4126 function, then the FUNCTION_CONTEXT is the function in which it is
4127 being instantiated. */
4130 lookup_template_class (tree d1,
4135 tsubst_flags_t complain)
4137 tree template = NULL_TREE, parmlist;
4140 timevar_push (TV_NAME_LOOKUP);
4142 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4144 if (IDENTIFIER_VALUE (d1)
4145 && DECL_TEMPLATE_TEMPLATE_PARM_P (IDENTIFIER_VALUE (d1)))
4146 template = IDENTIFIER_VALUE (d1);
4150 push_decl_namespace (context);
4151 template = lookup_name (d1, /*prefer_type=*/0);
4152 template = maybe_get_template_decl_from_type_decl (template);
4154 pop_decl_namespace ();
4157 context = DECL_CONTEXT (template);
4159 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4161 tree type = TREE_TYPE (d1);
4163 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4164 an implicit typename for the second A. Deal with it. */
4165 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4166 type = TREE_TYPE (type);
4168 if (CLASSTYPE_TEMPLATE_INFO (type))
4170 template = CLASSTYPE_TI_TEMPLATE (type);
4171 d1 = DECL_NAME (template);
4174 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4175 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4177 template = TYPE_TI_TEMPLATE (d1);
4178 d1 = DECL_NAME (template);
4180 else if (TREE_CODE (d1) == TEMPLATE_DECL
4181 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4184 d1 = DECL_NAME (template);
4185 context = DECL_CONTEXT (template);
4188 /* With something like `template <class T> class X class X { ... };'
4189 we could end up with D1 having nothing but an IDENTIFIER_VALUE.
4190 We don't want to do that, but we have to deal with the situation,
4191 so let's give them some syntax errors to chew on instead of a
4192 crash. Alternatively D1 might not be a template type at all. */
4195 if (complain & tf_error)
4196 error ("`%T' is not a template", d1);
4197 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4200 if (TREE_CODE (template) != TEMPLATE_DECL
4201 /* Make sure it's a user visible template, if it was named by
4203 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4204 && !PRIMARY_TEMPLATE_P (template)))
4206 if (complain & tf_error)
4208 error ("non-template type `%T' used as a template", d1);
4210 cp_error_at ("for template declaration `%D'", in_decl);
4212 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4215 complain &= ~tf_user;
4217 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4219 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4220 template arguments */
4225 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4227 /* Consider an example where a template template parameter declared as
4229 template <class T, class U = std::allocator<T> > class TT
4231 The template parameter level of T and U are one level larger than
4232 of TT. To proper process the default argument of U, say when an
4233 instantiation `TT<int>' is seen, we need to build the full
4234 arguments containing {int} as the innermost level. Outer levels,
4235 available when not appearing as default template argument, can be
4236 obtained from `current_template_args ()'.
4238 Suppose that TT is later substituted with std::vector. The above
4239 instantiation is `TT<int, std::allocator<T> >' with TT at
4240 level 1, and T at level 2, while the template arguments at level 1
4241 becomes {std::vector} and the inner level 2 is {int}. */
4243 if (current_template_parms)
4244 arglist = add_to_template_args (current_template_args (), arglist);
4246 arglist2 = coerce_template_parms (parmlist, arglist, template,
4247 complain, /*require_all_args=*/1);
4248 if (arglist2 == error_mark_node
4249 || (!uses_template_parms (arglist2)
4250 && check_instantiated_args (template, arglist2, complain)))
4251 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4253 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4254 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4258 tree template_type = TREE_TYPE (template);
4261 tree found = NULL_TREE;
4265 int is_partial_instantiation;
4267 gen_tmpl = most_general_template (template);
4268 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4269 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4270 arg_depth = TMPL_ARGS_DEPTH (arglist);
4272 if (arg_depth == 1 && parm_depth > 1)
4274 /* We've been given an incomplete set of template arguments.
4277 template <class T> struct S1 {
4278 template <class U> struct S2 {};
4279 template <class U> struct S2<U*> {};
4282 we will be called with an ARGLIST of `U*', but the
4283 TEMPLATE will be `template <class T> template
4284 <class U> struct S1<T>::S2'. We must fill in the missing
4287 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4289 arg_depth = TMPL_ARGS_DEPTH (arglist);
4292 /* Now we should have enough arguments. */
4293 my_friendly_assert (parm_depth == arg_depth, 0);
4295 /* From here on, we're only interested in the most general
4297 template = gen_tmpl;
4299 /* Calculate the BOUND_ARGS. These will be the args that are
4300 actually tsubst'd into the definition to create the
4304 /* We have multiple levels of arguments to coerce, at once. */
4306 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4308 tree bound_args = make_tree_vec (parm_depth);
4310 for (i = saved_depth,
4311 t = DECL_TEMPLATE_PARMS (template);
4312 i > 0 && t != NULL_TREE;
4313 --i, t = TREE_CHAIN (t))
4315 tree a = coerce_template_parms (TREE_VALUE (t),
4317 complain, /*require_all_args=*/1);
4319 /* Don't process further if one of the levels fails. */
4320 if (a == error_mark_node)
4322 /* Restore the ARGLIST to its full size. */
4323 TREE_VEC_LENGTH (arglist) = saved_depth;
4324 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4327 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4329 /* We temporarily reduce the length of the ARGLIST so
4330 that coerce_template_parms will see only the arguments
4331 corresponding to the template parameters it is
4333 TREE_VEC_LENGTH (arglist)--;
4336 /* Restore the ARGLIST to its full size. */
4337 TREE_VEC_LENGTH (arglist) = saved_depth;
4339 arglist = bound_args;
4343 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4344 INNERMOST_TEMPLATE_ARGS (arglist),
4346 complain, /*require_all_args=*/1);
4348 if (arglist == error_mark_node)
4349 /* We were unable to bind the arguments. */
4350 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4352 /* In the scope of a template class, explicit references to the
4353 template class refer to the type of the template, not any
4354 instantiation of it. For example, in:
4356 template <class T> class C { void f(C<T>); }
4358 the `C<T>' is just the same as `C'. Outside of the
4359 class, however, such a reference is an instantiation. */
4360 if (comp_template_args (TYPE_TI_ARGS (template_type),
4363 found = template_type;
4365 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4369 for (ctx = current_class_type;
4370 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4372 ? TYPE_CONTEXT (ctx)
4373 : DECL_CONTEXT (ctx)))
4374 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4377 /* We're not in the scope of the class, so the
4378 TEMPLATE_TYPE is not the type we want after all. */
4384 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4386 for (tp = &DECL_TEMPLATE_INSTANTIATIONS (template);
4388 tp = &TREE_CHAIN (*tp))
4389 if (comp_template_args (TREE_PURPOSE (*tp), arglist))
4393 /* Use the move-to-front heuristic to speed up future
4395 *tp = TREE_CHAIN (*tp);
4397 = DECL_TEMPLATE_INSTANTIATIONS (template);
4398 DECL_TEMPLATE_INSTANTIATIONS (template) = found;
4400 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_VALUE (found));
4403 /* This type is a "partial instantiation" if any of the template
4404 arguments still involve template parameters. Note that we set
4405 IS_PARTIAL_INSTANTIATION for partial specializations as
4407 is_partial_instantiation = uses_template_parms (arglist);
4409 /* If the deduced arguments are invalid, then the binding
4411 if (!is_partial_instantiation
4412 && check_instantiated_args (template,
4413 INNERMOST_TEMPLATE_ARGS (arglist),
4415 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4417 if (!is_partial_instantiation
4418 && !PRIMARY_TEMPLATE_P (template)
4419 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4421 found = xref_tag_from_type (TREE_TYPE (template),
4422 DECL_NAME (template),
4424 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4427 context = tsubst (DECL_CONTEXT (template), arglist,
4430 context = global_namespace;
4432 /* Create the type. */
4433 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4435 if (!is_partial_instantiation)
4437 set_current_access_from_decl (TYPE_NAME (template_type));
4438 t = start_enum (TYPE_IDENTIFIER (template_type));
4441 /* We don't want to call start_enum for this type, since
4442 the values for the enumeration constants may involve
4443 template parameters. And, no one should be interested
4444 in the enumeration constants for such a type. */
4445 t = make_node (ENUMERAL_TYPE);
4449 t = make_aggr_type (TREE_CODE (template_type));
4450 CLASSTYPE_DECLARED_CLASS (t)
4451 = CLASSTYPE_DECLARED_CLASS (template_type);
4452 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4453 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4455 /* A local class. Make sure the decl gets registered properly. */
4456 if (context == current_function_decl)
4457 pushtag (DECL_NAME (template), t, 0);
4460 /* If we called start_enum or pushtag above, this information
4461 will already be set up. */
4464 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4466 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4467 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4468 TYPE_STUB_DECL (t) = type_decl;
4469 DECL_SOURCE_LOCATION (type_decl)
4470 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4473 type_decl = TYPE_NAME (t);
4475 TREE_PRIVATE (type_decl)
4476 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4477 TREE_PROTECTED (type_decl)
4478 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4480 /* Set up the template information. We have to figure out which
4481 template is the immediate parent if this is a full
4483 if (parm_depth == 1 || is_partial_instantiation
4484 || !PRIMARY_TEMPLATE_P (template))
4485 /* This case is easy; there are no member templates involved. */
4489 /* This is a full instantiation of a member template. Look
4490 for a partial instantiation of which this is an instance. */
4492 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4493 found; found = TREE_CHAIN (found))
4496 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4498 /* We only want partial instantiations, here, not
4499 specializations or full instantiations. */
4500 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4501 || !uses_template_parms (TREE_VALUE (found)))
4504 /* Temporarily reduce by one the number of levels in the
4505 ARGLIST and in FOUND so as to avoid comparing the
4506 last set of arguments. */
4507 TREE_VEC_LENGTH (arglist)--;
4508 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4510 /* See if the arguments match. If they do, then TMPL is
4511 the partial instantiation we want. */
4512 success = comp_template_args (TREE_PURPOSE (found), arglist);
4514 /* Restore the argument vectors to their full size. */
4515 TREE_VEC_LENGTH (arglist)++;
4516 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4527 /* There was no partial instantiation. This happens
4528 where C<T> is a member template of A<T> and it's used
4531 template <typename T> struct B { A<T>::C<int> m; };
4534 Create the partial instantiation.
4536 TREE_VEC_LENGTH (arglist)--;
4537 found = tsubst (template, arglist, complain, NULL_TREE);
4538 TREE_VEC_LENGTH (arglist)++;
4542 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4543 DECL_TEMPLATE_INSTANTIATIONS (template)
4544 = tree_cons (arglist, t,
4545 DECL_TEMPLATE_INSTANTIATIONS (template));
4547 if (TREE_CODE (t) == ENUMERAL_TYPE
4548 && !is_partial_instantiation)
4549 /* Now that the type has been registered on the instantiations
4550 list, we set up the enumerators. Because the enumeration
4551 constants may involve the enumeration type itself, we make
4552 sure to register the type first, and then create the
4553 constants. That way, doing tsubst_expr for the enumeration
4554 constants won't result in recursive calls here; we'll find
4555 the instantiation and exit above. */
4556 tsubst_enum (template_type, t, arglist);
4558 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4560 if (TREE_CODE (t) != ENUMERAL_TYPE)
4561 DECL_NAME (type_decl) = classtype_mangled_name (t);
4562 if (is_partial_instantiation)
4563 /* If the type makes use of template parameters, the
4564 code that generates debugging information will crash. */
4565 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4567 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4569 timevar_pop (TV_NAME_LOOKUP);
4579 /* Called from for_each_template_parm via walk_tree. */
4582 for_each_template_parm_r (tree* tp, int* walk_subtrees, void* d)
4585 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4586 tree_fn_t fn = pfd->fn;
4587 void *data = pfd->data;
4590 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4591 return error_mark_node;
4593 switch (TREE_CODE (t))
4596 if (TYPE_PTRMEMFUNC_P (t))
4602 if (!TYPE_TEMPLATE_INFO (t))
4604 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4605 fn, data, pfd->visited))
4606 return error_mark_node;
4610 /* Since we're not going to walk subtrees, we have to do this
4612 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4614 return error_mark_node;
4618 /* Check the return type. */
4619 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4620 return error_mark_node;
4622 /* Check the parameter types. Since default arguments are not
4623 instantiated until they are needed, the TYPE_ARG_TYPES may
4624 contain expressions that involve template parameters. But,
4625 no-one should be looking at them yet. And, once they're
4626 instantiated, they don't contain template parameters, so
4627 there's no point in looking at them then, either. */
4631 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4632 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
4634 return error_mark_node;
4636 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4637 want walk_tree walking into them itself. */
4643 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
4645 return error_mark_node;
4650 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
4651 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
4653 return error_mark_node;
4658 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
4659 && for_each_template_parm (DECL_INITIAL (t), fn, data,
4661 return error_mark_node;
4662 if (DECL_CONTEXT (t)
4663 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
4665 return error_mark_node;
4668 case BOUND_TEMPLATE_TEMPLATE_PARM:
4669 /* Record template parameters such as `T' inside `TT<T>'. */
4670 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
4671 return error_mark_node;
4674 case TEMPLATE_TEMPLATE_PARM:
4675 case TEMPLATE_TYPE_PARM:
4676 case TEMPLATE_PARM_INDEX:
4677 if (fn && (*fn)(t, data))
4678 return error_mark_node;
4680 return error_mark_node;
4684 /* A template template parameter is encountered. */
4685 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
4686 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4687 return error_mark_node;
4689 /* Already substituted template template parameter */
4695 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
4696 data, pfd->visited))
4697 return error_mark_node;
4701 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
4702 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4703 (TREE_TYPE (t)), fn, data,
4705 return error_mark_node;
4710 /* If there's no type, then this thing must be some expression
4711 involving template parameters. */
4712 if (!fn && !TREE_TYPE (t))
4713 return error_mark_node;
4718 case REINTERPRET_CAST_EXPR:
4719 case CONST_CAST_EXPR:
4720 case STATIC_CAST_EXPR:
4721 case DYNAMIC_CAST_EXPR:
4725 case PSEUDO_DTOR_EXPR:
4727 return error_mark_node;
4731 /* If we do not handle this case specially, we end up walking
4732 the BINFO hierarchy, which is circular, and therefore
4733 confuses walk_tree. */
4735 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
4737 return error_mark_node;
4744 /* We didn't find any template parameters we liked. */
4748 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
4749 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
4750 call FN with the parameter and the DATA.
4751 If FN returns nonzero, the iteration is terminated, and
4752 for_each_template_parm returns 1. Otherwise, the iteration
4753 continues. If FN never returns a nonzero value, the value
4754 returned by for_each_template_parm is 0. If FN is NULL, it is
4755 considered to be the function which always returns 1. */
4758 for_each_template_parm (tree t, tree_fn_t fn, void* data, htab_t visited)
4760 struct pair_fn_data pfd;
4767 /* Walk the tree. (Conceptually, we would like to walk without
4768 duplicates, but for_each_template_parm_r recursively calls
4769 for_each_template_parm, so we would need to reorganize a fair
4770 bit to use walk_tree_without_duplicates, so we keep our own
4773 pfd.visited = visited;
4775 pfd.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer,
4777 result = walk_tree (&t,
4778 for_each_template_parm_r,
4780 pfd.visited) != NULL_TREE;
4784 htab_delete (pfd.visited);
4789 /* Returns true if T depends on any template parameter. */
4792 uses_template_parms (tree t)
4795 int saved_processing_template_decl;
4797 saved_processing_template_decl = processing_template_decl;
4798 if (!saved_processing_template_decl)
4799 processing_template_decl = 1;
4801 dependent_p = dependent_type_p (t);
4802 else if (TREE_CODE (t) == TREE_VEC)
4803 dependent_p = any_dependent_template_arguments_p (t);
4804 else if (TREE_CODE (t) == TREE_LIST)
4805 dependent_p = (uses_template_parms (TREE_VALUE (t))
4806 || uses_template_parms (TREE_CHAIN (t)));
4809 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
4810 || TREE_CODE (t) == OVERLOAD
4811 || TREE_CODE (t) == BASELINK
4812 || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
4813 dependent_p = (type_dependent_expression_p (t)
4814 || value_dependent_expression_p (t));
4815 else if (t == error_mark_node)
4816 dependent_p = false;
4819 processing_template_decl = saved_processing_template_decl;
4824 /* Returns true if T depends on any template parameter with level LEVEL. */
4827 uses_template_parms_level (tree t, int level)
4829 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
4832 static int tinst_depth;
4833 extern int max_tinst_depth;
4834 #ifdef GATHER_STATISTICS
4837 static int tinst_level_tick;
4838 static int last_template_error_tick;
4840 /* We're starting to instantiate D; record the template instantiation context
4841 for diagnostics and to restore it later. */
4844 push_tinst_level (tree d)
4848 if (tinst_depth >= max_tinst_depth)
4850 /* If the instantiation in question still has unbound template parms,
4851 we don't really care if we can't instantiate it, so just return.
4852 This happens with base instantiation for implicit `typename'. */
4853 if (uses_template_parms (d))
4856 last_template_error_tick = tinst_level_tick;
4857 error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",
4858 max_tinst_depth, d);
4860 print_instantiation_context ();
4865 new = build_expr_wfl (d, input_filename, input_line, 0);
4866 TREE_CHAIN (new) = current_tinst_level;
4867 current_tinst_level = new;
4870 #ifdef GATHER_STATISTICS
4871 if (tinst_depth > depth_reached)
4872 depth_reached = tinst_depth;
4879 /* We're done instantiating this template; return to the instantiation
4883 pop_tinst_level (void)
4885 tree old = current_tinst_level;
4887 /* Restore the filename and line number stashed away when we started
4888 this instantiation. */
4889 input_line = TINST_LINE (old);
4890 input_filename = TINST_FILE (old);
4891 extract_interface_info ();
4893 current_tinst_level = TREE_CHAIN (old);
4898 /* We're instantiating a deferred template; restore the template
4899 instantiation context in which the instantiation was requested, which
4900 is one step out from LEVEL. */
4903 reopen_tinst_level (tree level)
4908 for (t = level; t; t = TREE_CHAIN (t))
4911 current_tinst_level = level;
4915 /* Return the outermost template instantiation context, for use with
4916 -falt-external-templates. */
4919 tinst_for_decl (void)
4921 tree p = current_tinst_level;
4924 for (; TREE_CHAIN (p) ; p = TREE_CHAIN (p))
4929 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
4930 vector of template arguments, as for tsubst.
4932 Returns an appropriate tsubst'd friend declaration. */
4935 tsubst_friend_function (tree decl, tree args)
4938 location_t saved_loc = input_location;
4940 input_location = DECL_SOURCE_LOCATION (decl);
4942 if (TREE_CODE (decl) == FUNCTION_DECL
4943 && DECL_TEMPLATE_INSTANTIATION (decl)
4944 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
4945 /* This was a friend declared with an explicit template
4946 argument list, e.g.:
4950 to indicate that f was a template instantiation, not a new
4951 function declaration. Now, we have to figure out what
4952 instantiation of what template. */
4954 tree template_id, arglist, fns;
4957 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
4959 /* Friend functions are looked up in the containing namespace scope.
4960 We must enter that scope, to avoid finding member functions of the
4961 current cless with same name. */
4962 push_nested_namespace (ns);
4963 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
4964 tf_error | tf_warning, NULL_TREE);
4965 pop_nested_namespace (ns);
4966 arglist = tsubst (DECL_TI_ARGS (decl), args,
4967 tf_error | tf_warning, NULL_TREE);
4968 template_id = lookup_template_function (fns, arglist);
4970 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
4971 tmpl = determine_specialization (template_id, new_friend,
4973 /*need_member_template=*/0);
4974 new_friend = instantiate_template (tmpl, new_args, tf_error);
4978 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
4980 /* The NEW_FRIEND will look like an instantiation, to the
4981 compiler, but is not an instantiation from the point of view of
4982 the language. For example, we might have had:
4984 template <class T> struct S {
4985 template <class U> friend void f(T, U);
4988 Then, in S<int>, template <class U> void f(int, U) is not an
4989 instantiation of anything. */
4990 if (new_friend == error_mark_node)
4991 return error_mark_node;
4993 DECL_USE_TEMPLATE (new_friend) = 0;
4994 if (TREE_CODE (decl) == TEMPLATE_DECL)
4996 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
4997 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
4998 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5001 /* The mangled name for the NEW_FRIEND is incorrect. The function
5002 is not a template instantiation and should not be mangled like
5003 one. Therefore, we forget the mangling here; we'll recompute it
5004 later if we need it. */
5005 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5007 SET_DECL_RTL (new_friend, NULL_RTX);
5008 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5011 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5014 tree new_friend_template_info;
5015 tree new_friend_result_template_info;
5017 int new_friend_is_defn;
5019 /* We must save some information from NEW_FRIEND before calling
5020 duplicate decls since that function will free NEW_FRIEND if
5022 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5023 new_friend_is_defn =
5024 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5025 (template_for_substitution (new_friend)))
5027 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5029 /* This declaration is a `primary' template. */
5030 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5032 new_friend_result_template_info
5033 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5036 new_friend_result_template_info = NULL_TREE;
5038 /* Inside pushdecl_namespace_level, we will push into the
5039 current namespace. However, the friend function should go
5040 into the namespace of the template. */
5041 ns = decl_namespace_context (new_friend);
5042 push_nested_namespace (ns);
5043 old_decl = pushdecl_namespace_level (new_friend);
5044 pop_nested_namespace (ns);
5046 if (old_decl != new_friend)
5048 /* This new friend declaration matched an existing
5049 declaration. For example, given:
5051 template <class T> void f(T);
5052 template <class U> class C {
5053 template <class T> friend void f(T) {}
5056 the friend declaration actually provides the definition
5057 of `f', once C has been instantiated for some type. So,
5058 old_decl will be the out-of-class template declaration,
5059 while new_friend is the in-class definition.
5061 But, if `f' was called before this point, the
5062 instantiation of `f' will have DECL_TI_ARGS corresponding
5063 to `T' but not to `U', references to which might appear
5064 in the definition of `f'. Previously, the most general
5065 template for an instantiation of `f' was the out-of-class
5066 version; now it is the in-class version. Therefore, we
5067 run through all specialization of `f', adding to their
5068 DECL_TI_ARGS appropriately. In particular, they need a
5069 new set of outer arguments, corresponding to the
5070 arguments for this class instantiation.
5072 The same situation can arise with something like this:
5075 template <class T> class C {
5079 when `C<int>' is instantiated. Now, `f(int)' is defined
5082 if (!new_friend_is_defn)
5083 /* On the other hand, if the in-class declaration does
5084 *not* provide a definition, then we don't want to alter
5085 existing definitions. We can just leave everything
5090 /* Overwrite whatever template info was there before, if
5091 any, with the new template information pertaining to
5093 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5095 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5096 reregister_specialization (new_friend,
5097 most_general_template (old_decl),
5102 tree new_friend_args;
5104 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5105 = new_friend_result_template_info;
5107 new_friend_args = TI_ARGS (new_friend_template_info);
5108 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5112 tree spec = TREE_VALUE (t);
5115 = add_outermost_template_args (new_friend_args,
5116 DECL_TI_ARGS (spec));
5119 /* Now, since specializations are always supposed to
5120 hang off of the most general template, we must move
5122 t = most_general_template (old_decl);
5125 DECL_TEMPLATE_SPECIALIZATIONS (t)
5126 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5127 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5128 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5133 /* The information from NEW_FRIEND has been merged into OLD_DECL
5134 by duplicate_decls. */
5135 new_friend = old_decl;
5138 else if (COMPLETE_TYPE_P (DECL_CONTEXT (new_friend)))
5140 /* Check to see that the declaration is really present, and,
5141 possibly obtain an improved declaration. */
5142 tree fn = check_classfn (DECL_CONTEXT (new_friend),
5150 input_location = saved_loc;
5154 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5155 template arguments, as for tsubst.
5157 Returns an appropriate tsubst'd friend type or error_mark_node on
5161 tsubst_friend_class (tree friend_tmpl, tree args)
5167 context = DECL_CONTEXT (friend_tmpl);
5171 if (TREE_CODE (context) == NAMESPACE_DECL)
5172 push_nested_namespace (context);
5174 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5177 /* First, we look for a class template. */
5178 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0);
5180 /* But, if we don't find one, it might be because we're in a
5181 situation like this:
5189 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5190 for `S<int>', not the TEMPLATE_DECL. */
5191 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5193 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1);
5194 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5197 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5199 /* The friend template has already been declared. Just
5200 check to see that the declarations match, and install any new
5201 default parameters. We must tsubst the default parameters,
5202 of course. We only need the innermost template parameters
5203 because that is all that redeclare_class_template will look
5205 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5206 > TMPL_ARGS_DEPTH (args))
5209 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5210 args, tf_error | tf_warning);
5211 redeclare_class_template (TREE_TYPE (tmpl), parms);
5214 friend_type = TREE_TYPE (tmpl);
5218 /* The friend template has not already been declared. In this
5219 case, the instantiation of the template class will cause the
5220 injection of this template into the global scope. */
5221 tmpl = tsubst (friend_tmpl, args, tf_error | tf_warning, NULL_TREE);
5223 /* The new TMPL is not an instantiation of anything, so we
5224 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5225 the new type because that is supposed to be the corresponding
5226 template decl, i.e., TMPL. */
5227 DECL_USE_TEMPLATE (tmpl) = 0;
5228 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5229 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5230 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5231 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5233 /* Inject this template into the global scope. */
5234 friend_type = TREE_TYPE (pushdecl_top_level (tmpl));
5239 if (TREE_CODE (context) == NAMESPACE_DECL)
5240 pop_nested_namespace (context);
5242 pop_nested_class ();
5248 /* Returns zero if TYPE cannot be completed later due to circularity.
5249 Otherwise returns one. */
5252 can_complete_type_without_circularity (tree type)
5254 if (type == NULL_TREE || type == error_mark_node)
5256 else if (COMPLETE_TYPE_P (type))
5258 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5259 return can_complete_type_without_circularity (TREE_TYPE (type));
5260 else if (CLASS_TYPE_P (type)
5261 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5268 instantiate_class_template (tree type)
5270 tree template, args, pattern, t, member;
5274 if (type == error_mark_node)
5275 return error_mark_node;
5277 if (TYPE_BEING_DEFINED (type)
5278 || COMPLETE_TYPE_P (type)
5279 || dependent_type_p (type))
5282 /* Figure out which template is being instantiated. */
5283 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5284 my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279);
5286 /* Figure out which arguments are being used to do the
5288 args = CLASSTYPE_TI_ARGS (type);
5290 /* Determine what specialization of the original template to
5292 t = most_specialized_class (template, args);
5293 if (t == error_mark_node)
5295 const char *str = "candidates are:";
5296 error ("ambiguous class template instantiation for `%#T'", type);
5297 for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t;
5300 if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args))
5302 cp_error_at ("%s %+#T", str, TREE_TYPE (t));
5306 TYPE_BEING_DEFINED (type) = 1;
5307 return error_mark_node;
5311 pattern = TREE_TYPE (t);
5313 pattern = TREE_TYPE (template);
5315 /* If the template we're instantiating is incomplete, then clearly
5316 there's nothing we can do. */
5317 if (!COMPLETE_TYPE_P (pattern))
5320 /* If we've recursively instantiated too many templates, stop. */
5321 if (! push_tinst_level (type))
5324 /* Now we're really doing the instantiation. Mark the type as in
5325 the process of being defined. */
5326 TYPE_BEING_DEFINED (type) = 1;
5328 /* We may be in the middle of deferred access check. Disable
5330 push_deferring_access_checks (dk_no_deferred);
5332 push_to_top_level ();
5336 /* This TYPE is actually an instantiation of a partial
5337 specialization. We replace the innermost set of ARGS with
5338 the arguments appropriate for substitution. For example,
5341 template <class T> struct S {};
5342 template <class T> struct S<T*> {};
5344 and supposing that we are instantiating S<int*>, ARGS will
5345 present be {int*} but we need {int}. */
5347 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t),
5350 /* If there were multiple levels in ARGS, replacing the
5351 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
5352 want, so we make a copy first. */
5353 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
5355 args = copy_node (args);
5356 SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args);
5362 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5364 /* Set the input location to the template definition. This is needed
5365 if tsubsting causes an error. */
5366 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (pattern));
5368 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5369 TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern);
5370 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5371 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5372 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5373 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5374 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5375 TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern);
5376 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5377 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5378 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5379 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5380 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
5381 = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (pattern);
5382 TYPE_USES_MULTIPLE_INHERITANCE (type)
5383 = TYPE_USES_MULTIPLE_INHERITANCE (pattern);
5384 TYPE_USES_VIRTUAL_BASECLASSES (type)
5385 = TYPE_USES_VIRTUAL_BASECLASSES (pattern);
5386 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5387 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5388 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5389 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5390 if (ANON_AGGR_TYPE_P (pattern))
5391 SET_ANON_AGGR_TYPE_P (type);
5393 pbinfo = TYPE_BINFO (pattern);
5395 #ifdef ENABLE_CHECKING
5396 if (DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5397 && ! COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5398 && ! TYPE_BEING_DEFINED (TYPE_CONTEXT (type)))
5399 /* We should never instantiate a nested class before its enclosing
5400 class; we need to look up the nested class by name before we can
5401 instantiate it, and that lookup should instantiate the enclosing
5406 if (BINFO_BASETYPES (pbinfo))
5408 tree base_list = NULL_TREE;
5409 tree pbases = BINFO_BASETYPES (pbinfo);
5410 tree paccesses = BINFO_BASEACCESSES (pbinfo);
5411 tree context = TYPE_CONTEXT (type);
5415 /* We must enter the scope containing the type, as that is where
5416 the accessibility of types named in dependent bases are
5418 pop_p = push_scope (context ? context : global_namespace);
5420 /* Substitute into each of the bases to determine the actual
5422 for (i = 0; i < TREE_VEC_LENGTH (pbases); ++i)
5428 pbase = TREE_VEC_ELT (pbases, i);
5429 access = TREE_VEC_ELT (paccesses, i);
5431 /* Substitute to figure out the base class. */
5432 base = tsubst (BINFO_TYPE (pbase), args, tf_error, NULL_TREE);
5433 if (base == error_mark_node)
5436 base_list = tree_cons (access, base, base_list);
5437 TREE_VIA_VIRTUAL (base_list) = TREE_VIA_VIRTUAL (pbase);
5440 /* The list is now in reverse order; correct that. */
5441 base_list = nreverse (base_list);
5443 /* Now call xref_basetypes to set up all the base-class
5445 xref_basetypes (type, base_list);
5448 pop_scope (context ? context : global_namespace);
5451 /* Now that our base classes are set up, enter the scope of the
5452 class, so that name lookups into base classes, etc. will work
5453 correctly. This is precisely analogous to what we do in
5454 begin_class_definition when defining an ordinary non-template
5458 /* Now members are processed in the order of declaration. */
5459 for (member = CLASSTYPE_DECL_LIST (pattern);
5460 member; member = TREE_CHAIN (member))
5462 tree t = TREE_VALUE (member);
5464 if (TREE_PURPOSE (member))
5468 /* Build new CLASSTYPE_NESTED_UTDS. */
5471 tree name = TYPE_IDENTIFIER (tag);
5473 bool class_template_p;
5475 class_template_p = (TREE_CODE (tag) != ENUMERAL_TYPE
5476 && TYPE_LANG_SPECIFIC (tag)
5477 && CLASSTYPE_IS_TEMPLATE (tag));
5478 /* If the member is a class template, then -- even after
5479 substituition -- there may be dependent types in the
5480 template argument list for the class. We increment
5481 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5482 that function will assume that no types are dependent
5483 when outside of a template. */
5484 if (class_template_p)
5485 ++processing_template_decl;
5486 newtag = tsubst (tag, args, tf_error, NULL_TREE);
5487 if (class_template_p)
5488 --processing_template_decl;
5489 if (newtag == error_mark_node)
5492 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5494 if (class_template_p)
5495 /* Unfortunately, lookup_template_class sets
5496 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5497 instantiation (i.e., for the type of a member
5498 template class nested within a template class.)
5499 This behavior is required for
5500 maybe_process_partial_specialization to work
5501 correctly, but is not accurate in this case;
5502 the TAG is not an instantiation of anything.
5503 (The corresponding TEMPLATE_DECL is an
5504 instantiation, but the TYPE is not.) */
5505 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5507 /* Now, we call pushtag to put this NEWTAG into the scope of
5508 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5509 pushtag calling push_template_decl. We don't have to do
5510 this for enums because it will already have been done in
5513 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5514 pushtag (name, newtag, /*globalize=*/0);
5517 else if (TREE_CODE (t) == FUNCTION_DECL
5518 || DECL_FUNCTION_TEMPLATE_P (t))
5520 /* Build new TYPE_METHODS. */
5523 if (TREE_CODE (t) == TEMPLATE_DECL)
5524 ++processing_template_decl;
5525 r = tsubst (t, args, tf_error, NULL_TREE);
5526 if (TREE_CODE (t) == TEMPLATE_DECL)
5527 --processing_template_decl;
5528 set_current_access_from_decl (r);
5529 grok_special_member_properties (r);
5530 finish_member_declaration (r);
5534 /* Build new TYPE_FIELDS. */
5536 if (TREE_CODE (t) != CONST_DECL)
5540 /* The the file and line for this declaration, to
5541 assist in error message reporting. Since we
5542 called push_tinst_level above, we don't need to
5544 input_location = DECL_SOURCE_LOCATION (t);
5546 if (TREE_CODE (t) == TEMPLATE_DECL)
5547 ++processing_template_decl;
5548 r = tsubst (t, args, tf_error | tf_warning, NULL_TREE);
5549 if (TREE_CODE (t) == TEMPLATE_DECL)
5550 --processing_template_decl;
5551 if (TREE_CODE (r) == VAR_DECL)
5555 if (DECL_INITIALIZED_IN_CLASS_P (r))
5556 init = tsubst_expr (DECL_INITIAL (t), args,
5557 tf_error | tf_warning, NULL_TREE);
5561 finish_static_data_member_decl
5562 (r, init, /*asmspec_tree=*/NULL_TREE, /*flags=*/0);
5564 if (DECL_INITIALIZED_IN_CLASS_P (r))
5565 check_static_variable_definition (r, TREE_TYPE (r));
5567 else if (TREE_CODE (r) == FIELD_DECL)
5569 /* Determine whether R has a valid type and can be
5570 completed later. If R is invalid, then it is
5571 replaced by error_mark_node so that it will not be
5572 added to TYPE_FIELDS. */
5573 tree rtype = TREE_TYPE (r);
5574 if (can_complete_type_without_circularity (rtype))
5575 complete_type (rtype);
5577 if (!COMPLETE_TYPE_P (rtype))
5579 cxx_incomplete_type_error (r, rtype);
5580 r = error_mark_node;
5584 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5585 such a thing will already have been added to the field
5586 list by tsubst_enum in finish_member_declaration in the
5587 CLASSTYPE_NESTED_UTDS case above. */
5588 if (!(TREE_CODE (r) == TYPE_DECL
5589 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5590 && DECL_ARTIFICIAL (r)))
5592 set_current_access_from_decl (r);
5593 finish_member_declaration (r);
5600 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5602 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5604 tree friend_type = t;
5605 tree new_friend_type;
5607 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5608 new_friend_type = tsubst_friend_class (friend_type, args);
5609 else if (uses_template_parms (friend_type))
5610 new_friend_type = tsubst (friend_type, args,
5611 tf_error | tf_warning, NULL_TREE);
5612 else if (CLASSTYPE_USE_TEMPLATE (friend_type))
5613 new_friend_type = friend_type;
5616 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
5618 /* The call to xref_tag_from_type does injection for friend
5620 push_nested_namespace (ns);
5622 xref_tag_from_type (friend_type, NULL_TREE, 1);
5623 pop_nested_namespace (ns);
5626 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5627 /* Trick make_friend_class into realizing that the friend
5628 we're adding is a template, not an ordinary class. It's
5629 important that we use make_friend_class since it will
5630 perform some error-checking and output cross-reference
5632 ++processing_template_decl;
5634 if (new_friend_type != error_mark_node)
5635 make_friend_class (type, new_friend_type,
5636 /*complain=*/false);
5638 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5639 --processing_template_decl;
5643 /* Build new DECL_FRIENDLIST. */
5646 if (TREE_CODE (t) == TEMPLATE_DECL)
5647 ++processing_template_decl;
5648 r = tsubst_friend_function (t, args);
5649 if (TREE_CODE (t) == TEMPLATE_DECL)
5650 --processing_template_decl;
5651 add_friend (type, r, /*complain=*/false);
5656 /* Set the file and line number information to whatever is given for
5657 the class itself. This puts error messages involving generated
5658 implicit functions at a predictable point, and the same point
5659 that would be used for non-template classes. */
5660 typedecl = TYPE_MAIN_DECL (type);
5661 input_location = DECL_SOURCE_LOCATION (typedecl);
5663 unreverse_member_declarations (type);
5664 finish_struct_1 (type);
5666 /* Clear this now so repo_template_used is happy. */
5667 TYPE_BEING_DEFINED (type) = 0;
5668 repo_template_used (type);
5670 /* Now that the class is complete, instantiate default arguments for
5671 any member functions. We don't do this earlier because the
5672 default arguments may reference members of the class. */
5673 if (!PRIMARY_TEMPLATE_P (template))
5674 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
5675 if (TREE_CODE (t) == FUNCTION_DECL
5676 /* Implicitly generated member functions will not have template
5677 information; they are not instantiations, but instead are
5678 created "fresh" for each instantiation. */
5679 && DECL_TEMPLATE_INFO (t))
5680 tsubst_default_arguments (t);
5683 pop_from_top_level ();
5684 pop_deferring_access_checks ();
5687 if (TYPE_CONTAINS_VPTR_P (type))
5688 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
5694 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
5700 else if (TYPE_P (t))
5701 r = tsubst (t, args, complain, in_decl);
5704 r = tsubst_expr (t, args, complain, in_decl);
5706 if (!uses_template_parms (r))
5708 /* Sometimes, one of the args was an expression involving a
5709 template constant parameter, like N - 1. Now that we've
5710 tsubst'd, we might have something like 2 - 1. This will
5711 confuse lookup_template_class, so we do constant folding
5712 here. We have to unset processing_template_decl, to fool
5713 tsubst_copy_and_build() into building an actual tree. */
5715 /* If the TREE_TYPE of ARG is not NULL_TREE, ARG is already
5716 as simple as it's going to get, and trying to reprocess
5717 the trees will break. Once tsubst_expr et al DTRT for
5718 non-dependent exprs, this code can go away, as the type
5719 will always be set. */
5722 int saved_processing_template_decl = processing_template_decl;
5723 processing_template_decl = 0;
5724 r = tsubst_copy_and_build (r, /*args=*/NULL_TREE,
5725 tf_error, /*in_decl=*/NULL_TREE,
5726 /*function_p=*/false);
5727 processing_template_decl = saved_processing_template_decl;
5735 /* Substitute ARGS into the vector or list of template arguments T. */
5738 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
5740 int len = TREE_VEC_LENGTH (t);
5741 int need_new = 0, i;
5742 tree *elts = alloca (len * sizeof (tree));
5744 for (i = 0; i < len; i++)
5746 tree orig_arg = TREE_VEC_ELT (t, i);
5749 if (TREE_CODE (orig_arg) == TREE_VEC)
5750 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
5752 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
5754 if (new_arg == error_mark_node)
5755 return error_mark_node;
5758 if (new_arg != orig_arg)
5765 t = make_tree_vec (len);
5766 for (i = 0; i < len; i++)
5767 TREE_VEC_ELT (t, i) = elts[i];
5772 /* Return the result of substituting ARGS into the template parameters
5773 given by PARMS. If there are m levels of ARGS and m + n levels of
5774 PARMS, then the result will contain n levels of PARMS. For
5775 example, if PARMS is `template <class T> template <class U>
5776 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5777 result will be `template <int*, double, class V>'. */
5780 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
5785 for (new_parms = &r;
5786 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
5787 new_parms = &(TREE_CHAIN (*new_parms)),
5788 parms = TREE_CHAIN (parms))
5791 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
5794 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
5796 tree tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
5797 tree default_value = TREE_PURPOSE (tuple);
5798 tree parm_decl = TREE_VALUE (tuple);
5800 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
5801 default_value = tsubst_template_arg (default_value, args,
5802 complain, NULL_TREE);
5804 tuple = build_tree_list (default_value, parm_decl);
5805 TREE_VEC_ELT (new_vec, i) = tuple;
5809 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
5810 - TMPL_ARGS_DEPTH (args)),
5811 new_vec, NULL_TREE);
5817 /* Substitute the ARGS into the indicated aggregate (or enumeration)
5818 type T. If T is not an aggregate or enumeration type, it is
5819 handled as if by tsubst. IN_DECL is as for tsubst. If
5820 ENTERING_SCOPE is nonzero, T is the context for a template which
5821 we are presently tsubst'ing. Return the substituted value. */
5824 tsubst_aggr_type (tree t,
5826 tsubst_flags_t complain,
5833 switch (TREE_CODE (t))
5836 if (TYPE_PTRMEMFUNC_P (t))
5837 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
5839 /* Else fall through. */
5842 if (TYPE_TEMPLATE_INFO (t))
5848 /* First, determine the context for the type we are looking
5850 context = TYPE_CONTEXT (t);
5852 context = tsubst_aggr_type (context, args, complain,
5853 in_decl, /*entering_scope=*/1);
5855 /* Then, figure out what arguments are appropriate for the
5856 type we are trying to find. For example, given:
5858 template <class T> struct S;
5859 template <class T, class U> void f(T, U) { S<U> su; }
5861 and supposing that we are instantiating f<int, double>,
5862 then our ARGS will be {int, double}, but, when looking up
5863 S we only want {double}. */
5864 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
5866 if (argvec == error_mark_node)
5867 return error_mark_node;
5869 r = lookup_template_class (t, argvec, in_decl, context,
5870 entering_scope, complain);
5872 return cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
5875 /* This is not a template type, so there's nothing to do. */
5879 return tsubst (t, args, complain, in_decl);
5883 /* Substitute into the default argument ARG (a default argument for
5884 FN), which has the indicated TYPE. */
5887 tsubst_default_argument (tree fn, tree type, tree arg)
5889 tree saved_class_ptr = NULL_TREE;
5890 tree saved_class_ref = NULL_TREE;
5892 /* This default argument came from a template. Instantiate the
5893 default argument here, not in tsubst. In the case of
5902 we must be careful to do name lookup in the scope of S<T>,
5903 rather than in the current class. */
5904 push_access_scope (fn);
5905 /* The default argument expression should not be considered to be
5906 within the scope of FN. Since push_access_scope sets
5907 current_function_decl, we must explicitly clear it here. */
5908 current_function_decl = NULL_TREE;
5909 /* The "this" pointer is not valid in a default argument. */
5912 saved_class_ptr = current_class_ptr;
5913 cp_function_chain->x_current_class_ptr = NULL_TREE;
5914 saved_class_ref = current_class_ref;
5915 cp_function_chain->x_current_class_ref = NULL_TREE;
5918 push_deferring_access_checks(dk_no_deferred);
5919 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
5920 tf_error | tf_warning, NULL_TREE);
5921 pop_deferring_access_checks();
5923 /* Restore the "this" pointer. */
5926 cp_function_chain->x_current_class_ptr = saved_class_ptr;
5927 cp_function_chain->x_current_class_ref = saved_class_ref;
5930 pop_access_scope (fn);
5932 /* Make sure the default argument is reasonable. */
5933 arg = check_default_argument (type, arg);
5938 /* Substitute into all the default arguments for FN. */
5941 tsubst_default_arguments (tree fn)
5946 tmpl_args = DECL_TI_ARGS (fn);
5948 /* If this function is not yet instantiated, we certainly don't need
5949 its default arguments. */
5950 if (uses_template_parms (tmpl_args))
5953 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
5955 arg = TREE_CHAIN (arg))
5956 if (TREE_PURPOSE (arg))
5957 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
5959 TREE_PURPOSE (arg));
5962 /* Substitute the ARGS into the T, which is a _DECL. TYPE is the
5963 (already computed) substitution of ARGS into TREE_TYPE (T), if
5964 appropriate. Return the result of the substitution. Issue error
5965 and warning messages under control of COMPLAIN. */
5968 tsubst_decl (tree t, tree args, tree type, tsubst_flags_t complain)
5970 location_t saved_loc;
5974 /* Set the filename and linenumber to improve error-reporting. */
5975 saved_loc = input_location;
5976 input_location = DECL_SOURCE_LOCATION (t);
5978 switch (TREE_CODE (t))
5982 /* We can get here when processing a member template function
5983 of a template class. */
5984 tree decl = DECL_TEMPLATE_RESULT (t);
5986 int is_template_template_parm = DECL_TEMPLATE_TEMPLATE_PARM_P (t);
5988 if (!is_template_template_parm)
5990 /* We might already have an instance of this template.
5991 The ARGS are for the surrounding class type, so the
5992 full args contain the tsubst'd args for the context,
5993 plus the innermost args from the template decl. */
5994 tree tmpl_args = DECL_CLASS_TEMPLATE_P (t)
5995 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
5996 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
5999 full_args = tsubst_template_args (tmpl_args, args,
6002 /* tsubst_template_args doesn't copy the vector if
6003 nothing changed. But, *something* should have
6005 my_friendly_assert (full_args != tmpl_args, 0);
6007 spec = retrieve_specialization (t, full_args);
6008 if (spec != NULL_TREE)
6015 /* Make a new template decl. It will be similar to the
6016 original, but will record the current template arguments.
6017 We also create a new function declaration, which is just
6018 like the old one, but points to this new template, rather
6019 than the old one. */
6021 my_friendly_assert (DECL_LANG_SPECIFIC (r) != 0, 0);
6022 TREE_CHAIN (r) = NULL_TREE;
6024 if (is_template_template_parm)
6026 tree new_decl = tsubst (decl, args, complain, in_decl);
6027 DECL_TEMPLATE_RESULT (r) = new_decl;
6028 TREE_TYPE (r) = TREE_TYPE (new_decl);
6033 = tsubst_aggr_type (DECL_CONTEXT (t), args,
6035 /*entering_scope=*/1);
6036 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6038 if (TREE_CODE (decl) == TYPE_DECL)
6040 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6041 if (new_type == error_mark_node)
6042 return error_mark_node;
6044 TREE_TYPE (r) = new_type;
6045 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6046 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6047 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6051 tree new_decl = tsubst (decl, args, complain, in_decl);
6052 if (new_decl == error_mark_node)
6053 return error_mark_node;
6055 DECL_TEMPLATE_RESULT (r) = new_decl;
6056 DECL_TI_TEMPLATE (new_decl) = r;
6057 TREE_TYPE (r) = TREE_TYPE (new_decl);
6058 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6061 SET_DECL_IMPLICIT_INSTANTIATION (r);
6062 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6063 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6065 /* The template parameters for this new template are all the
6066 template parameters for the old template, except the
6067 outermost level of parameters. */
6068 DECL_TEMPLATE_PARMS (r)
6069 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6072 if (PRIMARY_TEMPLATE_P (t))
6073 DECL_PRIMARY_TEMPLATE (r) = r;
6075 if (TREE_CODE (decl) != TYPE_DECL)
6076 /* Record this non-type partial instantiation. */
6077 register_specialization (r, t,
6078 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)));
6085 tree argvec = NULL_TREE;
6092 /* Nobody should be tsubst'ing into non-template functions. */
6093 my_friendly_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE, 0);
6095 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6100 /* If T is not dependent, just return it. We have to
6101 increment PROCESSING_TEMPLATE_DECL because
6102 value_dependent_expression_p assumes that nothing is
6103 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6104 ++processing_template_decl;
6105 dependent_p = value_dependent_expression_p (t);
6106 --processing_template_decl;
6110 /* Calculate the most general template of which R is a
6111 specialization, and the complete set of arguments used to
6113 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6114 argvec = tsubst_template_args (DECL_TI_ARGS
6115 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6116 args, complain, in_decl);
6118 /* Check to see if we already have this specialization. */
6119 spec = retrieve_specialization (gen_tmpl, argvec);
6127 /* We can see more levels of arguments than parameters if
6128 there was a specialization of a member template, like
6131 template <class T> struct S { template <class U> void f(); }
6132 template <> template <class U> void S<int>::f(U);
6134 Here, we'll be substituting into the specialization,
6135 because that's where we can find the code we actually
6136 want to generate, but we'll have enough arguments for
6137 the most general template.
6139 We also deal with the peculiar case:
6141 template <class T> struct S {
6142 template <class U> friend void f();
6144 template <class U> void f() {}
6146 template void f<double>();
6148 Here, the ARGS for the instantiation of will be {int,
6149 double}. But, we only need as many ARGS as there are
6150 levels of template parameters in CODE_PATTERN. We are
6151 careful not to get fooled into reducing the ARGS in
6154 template <class T> struct S { template <class U> void f(U); }
6155 template <class T> template <> void S<T>::f(int) {}
6157 which we can spot because the pattern will be a
6158 specialization in this case. */
6159 args_depth = TMPL_ARGS_DEPTH (args);
6161 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6162 if (args_depth > parms_depth
6163 && !DECL_TEMPLATE_SPECIALIZATION (t))
6164 args = get_innermost_template_args (args, parms_depth);
6168 /* This special case arises when we have something like this:
6170 template <class T> struct S {
6171 friend void f<int>(int, double);
6174 Here, the DECL_TI_TEMPLATE for the friend declaration
6175 will be an IDENTIFIER_NODE. We are being called from
6176 tsubst_friend_function, and we want only to create a
6177 new decl (R) with appropriate types so that we can call
6178 determine_specialization. */
6179 gen_tmpl = NULL_TREE;
6182 if (DECL_CLASS_SCOPE_P (t))
6184 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6188 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6189 complain, t, /*entering_scope=*/1);
6194 ctx = DECL_CONTEXT (t);
6196 type = tsubst (type, args, complain, in_decl);
6197 if (type == error_mark_node)
6198 return error_mark_node;
6200 /* We do NOT check for matching decls pushed separately at this
6201 point, as they may not represent instantiations of this
6202 template, and in any case are considered separate under the
6205 DECL_USE_TEMPLATE (r) = 0;
6206 TREE_TYPE (r) = type;
6207 /* Clear out the mangled name and RTL for the instantiation. */
6208 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6209 SET_DECL_RTL (r, NULL_RTX);
6210 DECL_INITIAL (r) = NULL_TREE;
6211 DECL_CONTEXT (r) = ctx;
6213 if (member && DECL_CONV_FN_P (r))
6214 /* Type-conversion operator. Reconstruct the name, in
6215 case it's the name of one of the template's parameters. */
6216 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6218 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6220 DECL_RESULT (r) = NULL_TREE;
6222 TREE_STATIC (r) = 0;
6223 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6224 DECL_EXTERNAL (r) = 1;
6225 DECL_INTERFACE_KNOWN (r) = 0;
6226 DECL_DEFER_OUTPUT (r) = 0;
6227 TREE_CHAIN (r) = NULL_TREE;
6228 DECL_PENDING_INLINE_INFO (r) = 0;
6229 DECL_PENDING_INLINE_P (r) = 0;
6230 DECL_SAVED_TREE (r) = NULL_TREE;
6232 if (DECL_CLONED_FUNCTION (r))
6234 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6236 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6237 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6240 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6241 this in the special friend case mentioned above where
6242 GEN_TMPL is NULL. */
6245 DECL_TEMPLATE_INFO (r)
6246 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6247 SET_DECL_IMPLICIT_INSTANTIATION (r);
6248 register_specialization (r, gen_tmpl, argvec);
6250 /* We're not supposed to instantiate default arguments
6251 until they are called, for a template. But, for a
6254 template <class T> void f ()
6255 { extern void g(int i = T()); }
6257 we should do the substitution when the template is
6258 instantiated. We handle the member function case in
6259 instantiate_class_template since the default arguments
6260 might refer to other members of the class. */
6262 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6263 && !uses_template_parms (argvec))
6264 tsubst_default_arguments (r);
6267 /* Copy the list of befriending classes. */
6268 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6270 friends = &TREE_CHAIN (*friends))
6272 *friends = copy_node (*friends);
6273 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6278 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6280 maybe_retrofit_in_chrg (r);
6281 if (DECL_CONSTRUCTOR_P (r))
6282 grok_ctor_properties (ctx, r);
6283 /* If this is an instantiation of a member template, clone it.
6284 If it isn't, that'll be handled by
6285 clone_constructors_and_destructors. */
6286 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6287 clone_function_decl (r, /*update_method_vec_p=*/0);
6289 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r)))
6290 grok_op_properties (r, (complain & tf_error) != 0);
6292 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6293 SET_DECL_FRIEND_CONTEXT (r,
6294 tsubst (DECL_FRIEND_CONTEXT (t),
6295 args, complain, in_decl));
6302 if (DECL_TEMPLATE_PARM_P (t))
6303 SET_DECL_TEMPLATE_PARM_P (r);
6305 TREE_TYPE (r) = type;
6306 c_apply_type_quals_to_decl (cp_type_quals (type), r);
6308 if (DECL_INITIAL (r))
6310 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6311 DECL_INITIAL (r) = TREE_TYPE (r);
6313 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6317 DECL_CONTEXT (r) = NULL_TREE;
6319 if (!DECL_TEMPLATE_PARM_P (r))
6320 DECL_ARG_TYPE (r) = type_passed_as (type);
6322 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6323 complain, TREE_CHAIN (t));
6330 TREE_TYPE (r) = type;
6331 c_apply_type_quals_to_decl (cp_type_quals (type), r);
6333 /* We don't have to set DECL_CONTEXT here; it is set by
6334 finish_member_declaration. */
6335 DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args,
6337 TREE_CHAIN (r) = NULL_TREE;
6338 if (VOID_TYPE_P (type))
6339 cp_error_at ("instantiation of `%D' as type `%T'", r, type);
6346 /* It is not a dependent using decl any more. */
6347 TREE_TYPE (r) = void_type_node;
6349 = tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
6351 = tsubst_copy (DECL_NAME (t), args, complain, in_decl);
6352 TREE_CHAIN (r) = NULL_TREE;
6357 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6358 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6360 /* If this is the canonical decl, we don't have to mess with
6361 instantiations, and often we can't (for typename, template
6362 type parms and such). Note that TYPE_NAME is not correct for
6363 the above test if we've copied the type for a typedef. */
6364 r = TYPE_NAME (type);
6372 tree argvec = NULL_TREE;
6373 tree gen_tmpl = NULL_TREE;
6375 tree tmpl = NULL_TREE;
6379 /* Assume this is a non-local variable. */
6382 if (TYPE_P (CP_DECL_CONTEXT (t)))
6383 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6385 in_decl, /*entering_scope=*/1);
6386 else if (DECL_NAMESPACE_SCOPE_P (t))
6387 ctx = DECL_CONTEXT (t);
6390 /* Subsequent calls to pushdecl will fill this in. */
6395 /* Check to see if we already have this specialization. */
6398 tmpl = DECL_TI_TEMPLATE (t);
6399 gen_tmpl = most_general_template (tmpl);
6400 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6401 spec = retrieve_specialization (gen_tmpl, argvec);
6404 spec = retrieve_local_specialization (t);
6413 if (TREE_CODE (r) == VAR_DECL)
6415 type = complete_type (type);
6416 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6417 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6418 type = check_var_type (DECL_NAME (r), type);
6420 else if (DECL_SELF_REFERENCE_P (t))
6421 SET_DECL_SELF_REFERENCE_P (r);
6422 TREE_TYPE (r) = type;
6423 c_apply_type_quals_to_decl (cp_type_quals (type), r);
6424 DECL_CONTEXT (r) = ctx;
6425 /* Clear out the mangled name and RTL for the instantiation. */
6426 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6427 SET_DECL_RTL (r, NULL_RTX);
6429 /* Don't try to expand the initializer until someone tries to use
6430 this variable; otherwise we run into circular dependencies. */
6431 DECL_INITIAL (r) = NULL_TREE;
6432 SET_DECL_RTL (r, NULL_RTX);
6433 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
6435 /* Even if the original location is out of scope, the newly
6436 substituted one is not. */
6437 if (TREE_CODE (r) == VAR_DECL)
6439 DECL_DEAD_FOR_LOCAL (r) = 0;
6440 DECL_INITIALIZED_P (r) = 0;
6445 /* A static data member declaration is always marked
6446 external when it is declared in-class, even if an
6447 initializer is present. We mimic the non-template
6449 DECL_EXTERNAL (r) = 1;
6451 register_specialization (r, gen_tmpl, argvec);
6452 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
6453 SET_DECL_IMPLICIT_INSTANTIATION (r);
6456 register_local_specialization (r, t);
6458 TREE_CHAIN (r) = NULL_TREE;
6467 /* Restore the file and line information. */
6468 input_location = saved_loc;
6473 /* Substitute into the ARG_TYPES of a function type. */
6476 tsubst_arg_types (tree arg_types,
6478 tsubst_flags_t complain,
6481 tree remaining_arg_types;
6484 tree result = NULL_TREE;
6486 if (!arg_types || arg_types == void_list_node)
6489 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
6490 args, complain, in_decl);
6491 if (remaining_arg_types == error_mark_node)
6492 return error_mark_node;
6494 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
6495 if (type == error_mark_node)
6496 return error_mark_node;
6497 if (VOID_TYPE_P (type))
6499 if (complain & tf_error)
6501 error ("invalid parameter type `%T'", type);
6503 cp_error_at ("in declaration `%D'", in_decl);
6505 return error_mark_node;
6508 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6509 top-level qualifiers as required. */
6510 type = TYPE_MAIN_VARIANT (type_decays_to (type));
6512 /* We do not substitute into default arguments here. The standard
6513 mandates that they be instantiated only when needed, which is
6514 done in build_over_call. */
6515 default_arg = TREE_PURPOSE (arg_types);
6517 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
6519 /* We've instantiated a template before its default arguments
6520 have been parsed. This can happen for a nested template
6521 class, and is not an error unless we require the default
6522 argument in a call of this function. */
6523 result = tree_cons (default_arg, type, remaining_arg_types);
6524 TREE_CHAIN (default_arg) = tree_cons (result, NULL_TREE,
6525 TREE_CHAIN (default_arg));
6528 result = hash_tree_cons (default_arg, type, remaining_arg_types);
6533 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6534 *not* handle the exception-specification for FNTYPE, because the
6535 initial substitution of explicitly provided template parameters
6536 during argument deduction forbids substitution into the
6537 exception-specification:
6541 All references in the function type of the function template to the
6542 corresponding template parameters are replaced by the specified tem-
6543 plate argument values. If a substitution in a template parameter or
6544 in the function type of the function template results in an invalid
6545 type, type deduction fails. [Note: The equivalent substitution in
6546 exception specifications is done only when the function is instanti-
6547 ated, at which point a program is ill-formed if the substitution
6548 results in an invalid type.] */
6551 tsubst_function_type (tree t,
6553 tsubst_flags_t complain,
6560 /* The TYPE_CONTEXT is not used for function/method types. */
6561 my_friendly_assert (TYPE_CONTEXT (t) == NULL_TREE, 0);
6563 /* Substitute the return type. */
6564 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6565 if (return_type == error_mark_node)
6566 return error_mark_node;
6568 /* Substitute the argument types. */
6569 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
6571 if (arg_types == error_mark_node)
6572 return error_mark_node;
6574 /* Construct a new type node and return it. */
6575 if (TREE_CODE (t) == FUNCTION_TYPE)
6576 fntype = build_function_type (return_type, arg_types);
6579 tree r = TREE_TYPE (TREE_VALUE (arg_types));
6580 if (! IS_AGGR_TYPE (r))
6584 Type deduction may fail for any of the following
6587 -- Attempting to create "pointer to member of T" when T
6588 is not a class type. */
6589 if (complain & tf_error)
6590 error ("creating pointer to member function of non-class type `%T'",
6592 return error_mark_node;
6595 fntype = build_method_type_directly (r, return_type,
6596 TREE_CHAIN (arg_types));
6598 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
6599 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
6604 /* Substitute into the PARMS of a call-declarator. */
6607 tsubst_call_declarator_parms (tree parms,
6609 tsubst_flags_t complain,
6616 if (!parms || parms == void_list_node)
6619 new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms),
6620 args, complain, in_decl);
6622 /* Figure out the type of this parameter. */
6623 type = tsubst (TREE_VALUE (parms), args, complain, in_decl);
6625 /* Figure out the default argument as well. Note that we use
6626 tsubst_expr since the default argument is really an expression. */
6627 defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl);
6629 /* Chain this parameter on to the front of those we have already
6630 processed. We don't use hash_tree_cons because that function
6631 doesn't check TREE_PARMLIST. */
6632 new_parms = tree_cons (defarg, type, new_parms);
6634 /* And note that these are parameters. */
6635 TREE_PARMLIST (new_parms) = 1;
6640 /* Take the tree structure T and replace template parameters used
6641 therein with the argument vector ARGS. IN_DECL is an associated
6642 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6643 Issue error and warning messages under control of COMPLAIN. Note
6644 that we must be relatively non-tolerant of extensions here, in
6645 order to preserve conformance; if we allow substitutions that
6646 should not be allowed, we may allow argument deductions that should
6647 not succeed, and therefore report ambiguous overload situations
6648 where there are none. In theory, we could allow the substitution,
6649 but indicate that it should have failed, and allow our caller to
6650 make sure that the right thing happens, but we don't try to do this
6653 This function is used for dealing with types, decls and the like;
6654 for expressions, use tsubst_expr or tsubst_copy. */
6657 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6661 if (t == NULL_TREE || t == error_mark_node
6662 || t == integer_type_node
6663 || t == void_type_node
6664 || t == char_type_node
6665 || t == unknown_type_node
6666 || TREE_CODE (t) == NAMESPACE_DECL)
6669 if (TREE_CODE (t) == IDENTIFIER_NODE)
6670 type = IDENTIFIER_TYPE_VALUE (t);
6672 type = TREE_TYPE (t);
6674 my_friendly_assert (type != unknown_type_node, 20030716);
6676 if (type && TREE_CODE (t) != FUNCTION_DECL
6677 && TREE_CODE (t) != TYPENAME_TYPE
6678 && TREE_CODE (t) != TEMPLATE_DECL
6679 && TREE_CODE (t) != IDENTIFIER_NODE
6680 && TREE_CODE (t) != FUNCTION_TYPE
6681 && TREE_CODE (t) != METHOD_TYPE)
6682 type = tsubst (type, args, complain, in_decl);
6683 if (type == error_mark_node)
6684 return error_mark_node;
6687 return tsubst_decl (t, args, type, complain);
6689 switch (TREE_CODE (t))
6694 return tsubst_aggr_type (t, args, complain, in_decl,
6695 /*entering_scope=*/0);
6698 case IDENTIFIER_NODE:
6710 if (t == integer_type_node)
6713 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
6714 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
6718 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
6720 /* The array dimension behaves like a non-type template arg,
6721 in that we want to fold it as much as possible. */
6722 max = tsubst_template_arg (omax, args, complain, in_decl);
6723 max = fold_non_dependent_expr (max);
6725 if (integer_zerop (omax))
6727 /* Still allow an explicit array of size zero. */
6729 pedwarn ("creating array with size zero");
6731 else if (integer_zerop (max)
6732 || (TREE_CODE (max) == INTEGER_CST
6733 && INT_CST_LT (max, integer_zero_node)))
6737 Type deduction may fail for any of the following
6740 Attempting to create an array with a size that is
6741 zero or negative. */
6742 if (complain & tf_error)
6743 error ("creating array with size zero (`%E')", max);
6745 return error_mark_node;
6748 return compute_array_index_type (NULL_TREE, max);
6751 case TEMPLATE_TYPE_PARM:
6752 case TEMPLATE_TEMPLATE_PARM:
6753 case BOUND_TEMPLATE_TEMPLATE_PARM:
6754 case TEMPLATE_PARM_INDEX:
6762 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
6763 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
6764 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6766 idx = TEMPLATE_TYPE_IDX (t);
6767 level = TEMPLATE_TYPE_LEVEL (t);
6771 idx = TEMPLATE_PARM_IDX (t);
6772 level = TEMPLATE_PARM_LEVEL (t);
6775 if (TREE_VEC_LENGTH (args) > 0)
6777 tree arg = NULL_TREE;
6779 levels = TMPL_ARGS_DEPTH (args);
6780 if (level <= levels)
6781 arg = TMPL_ARG (args, level, idx);
6783 if (arg == error_mark_node)
6784 return error_mark_node;
6785 else if (arg != NULL_TREE)
6787 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
6789 my_friendly_assert (TYPE_P (arg), 0);
6790 return cp_build_qualified_type_real
6791 (arg, cp_type_quals (arg) | cp_type_quals (t),
6792 complain | tf_ignore_bad_quals);
6794 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6796 /* We are processing a type constructed from
6797 a template template parameter. */
6798 tree argvec = tsubst (TYPE_TI_ARGS (t),
6799 args, complain, in_decl);
6800 if (argvec == error_mark_node)
6801 return error_mark_node;
6803 /* We can get a TEMPLATE_TEMPLATE_PARM here when
6804 we are resolving nested-types in the signature of
6805 a member function templates.
6806 Otherwise ARG is a TEMPLATE_DECL and is the real
6807 template to be instantiated. */
6808 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
6809 arg = TYPE_NAME (arg);
6811 r = lookup_template_class (arg,
6814 /*entering_scope=*/0,
6816 return cp_build_qualified_type_real
6817 (r, TYPE_QUALS (t), complain);
6820 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
6828 /* This can happen during the attempted tsubst'ing in
6829 unify. This means that we don't yet have any information
6830 about the template parameter in question. */
6833 /* If we get here, we must have been looking at a parm for a
6834 more deeply nested template. Make a new version of this
6835 template parameter, but with a lower level. */
6836 switch (TREE_CODE (t))
6838 case TEMPLATE_TYPE_PARM:
6839 case TEMPLATE_TEMPLATE_PARM:
6840 case BOUND_TEMPLATE_TEMPLATE_PARM:
6841 if (cp_type_quals (t))
6843 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
6844 r = cp_build_qualified_type_real
6845 (r, cp_type_quals (t),
6846 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
6847 ? tf_ignore_bad_quals : 0));
6852 TEMPLATE_TYPE_PARM_INDEX (r)
6853 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
6855 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
6856 TYPE_MAIN_VARIANT (r) = r;
6857 TYPE_POINTER_TO (r) = NULL_TREE;
6858 TYPE_REFERENCE_TO (r) = NULL_TREE;
6860 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
6862 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
6864 if (argvec == error_mark_node)
6865 return error_mark_node;
6867 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
6868 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
6873 case TEMPLATE_PARM_INDEX:
6874 r = reduce_template_parm_level (t, type, levels);
6886 tree purpose, value, chain, result;
6888 if (t == void_list_node)
6891 purpose = TREE_PURPOSE (t);
6894 purpose = tsubst (purpose, args, complain, in_decl);
6895 if (purpose == error_mark_node)
6896 return error_mark_node;
6898 value = TREE_VALUE (t);
6901 value = tsubst (value, args, complain, in_decl);
6902 if (value == error_mark_node)
6903 return error_mark_node;
6905 chain = TREE_CHAIN (t);
6906 if (chain && chain != void_type_node)
6908 chain = tsubst (chain, args, complain, in_decl);
6909 if (chain == error_mark_node)
6910 return error_mark_node;
6912 if (purpose == TREE_PURPOSE (t)
6913 && value == TREE_VALUE (t)
6914 && chain == TREE_CHAIN (t))
6916 if (TREE_PARMLIST (t))
6918 result = tree_cons (purpose, value, chain);
6919 TREE_PARMLIST (result) = 1;
6922 result = hash_tree_cons (purpose, value, chain);
6926 if (type != NULL_TREE)
6928 /* A binfo node. We always need to make a copy, of the node
6929 itself and of its BINFO_BASETYPES. */
6933 /* Make sure type isn't a typedef copy. */
6934 type = BINFO_TYPE (TYPE_BINFO (type));
6936 TREE_TYPE (t) = complete_type (type);
6937 if (IS_AGGR_TYPE (type))
6939 BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type);
6940 BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type);
6941 if (TYPE_BINFO_BASETYPES (type) != NULL_TREE)
6942 BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type));
6947 /* Otherwise, a vector of template arguments. */
6948 return tsubst_template_args (t, args, complain, in_decl);
6951 case REFERENCE_TYPE:
6953 enum tree_code code;
6955 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
6958 code = TREE_CODE (t);
6963 Type deduction may fail for any of the following
6966 -- Attempting to create a pointer to reference type.
6967 -- Attempting to create a reference to a reference type or
6968 a reference to void. */
6969 if (TREE_CODE (type) == REFERENCE_TYPE
6970 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
6972 static location_t last_loc;
6974 /* We keep track of the last time we issued this error
6975 message to avoid spewing a ton of messages during a
6976 single bad template instantiation. */
6977 if (complain & tf_error
6978 && (last_loc.line != input_line
6979 || last_loc.file != input_filename))
6981 if (TREE_CODE (type) == VOID_TYPE)
6982 error ("forming reference to void");
6984 error ("forming %s to reference type `%T'",
6985 (code == POINTER_TYPE) ? "pointer" : "reference",
6987 last_loc = input_location;
6990 return error_mark_node;
6992 else if (code == POINTER_TYPE)
6994 r = build_pointer_type (type);
6995 if (TREE_CODE (type) == METHOD_TYPE)
6996 r = build_ptrmemfunc_type (r);
6999 r = build_reference_type (type);
7000 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7002 if (r != error_mark_node)
7003 /* Will this ever be needed for TYPE_..._TO values? */
7010 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7011 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7015 Type deduction may fail for any of the following
7018 -- Attempting to create "pointer to member of T" when T
7019 is not a class type. */
7020 if (complain & tf_error)
7021 error ("creating pointer to member of non-class type `%T'", r);
7022 return error_mark_node;
7024 if (TREE_CODE (type) == REFERENCE_TYPE)
7026 if (complain & tf_error)
7027 error ("creating pointer to member reference type `%T'", type);
7029 return error_mark_node;
7031 my_friendly_assert (TREE_CODE (type) != METHOD_TYPE, 20011231);
7032 if (TREE_CODE (type) == FUNCTION_TYPE)
7034 /* This is really a method type. The cv qualifiers of the
7035 this pointer should _not_ be determined by the cv
7036 qualifiers of the class type. They should be held
7037 somewhere in the FUNCTION_TYPE, but we don't do that at
7038 the moment. Consider
7039 typedef void (Func) () const;
7041 template <typename T1> void Foo (Func T1::*);
7046 method_type = build_method_type_directly (TYPE_MAIN_VARIANT (r),
7048 TYPE_ARG_TYPES (type));
7049 return build_ptrmemfunc_type (build_pointer_type (method_type));
7052 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7062 fntype = tsubst_function_type (t, args, complain, in_decl);
7063 if (fntype == error_mark_node)
7064 return error_mark_node;
7066 /* Substitute the exception specification. */
7067 raises = TYPE_RAISES_EXCEPTIONS (t);
7070 tree list = NULL_TREE;
7072 if (! TREE_VALUE (raises))
7075 for (; raises != NULL_TREE; raises = TREE_CHAIN (raises))
7077 tree spec = TREE_VALUE (raises);
7079 spec = tsubst (spec, args, complain, in_decl);
7080 if (spec == error_mark_node)
7082 list = add_exception_specifier (list, spec, complain);
7084 fntype = build_exception_variant (fntype, list);
7090 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7091 if (domain == error_mark_node)
7092 return error_mark_node;
7094 /* As an optimization, we avoid regenerating the array type if
7095 it will obviously be the same as T. */
7096 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7099 /* These checks should match the ones in grokdeclarator.
7103 The deduction may fail for any of the following reasons:
7105 -- Attempting to create an array with an element type that
7106 is void, a function type, or a reference type, or [DR337]
7107 an abstract class type. */
7108 if (TREE_CODE (type) == VOID_TYPE
7109 || TREE_CODE (type) == FUNCTION_TYPE
7110 || TREE_CODE (type) == REFERENCE_TYPE)
7112 if (complain & tf_error)
7113 error ("creating array of `%T'", type);
7114 return error_mark_node;
7116 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7118 if (complain & tf_error)
7119 error ("creating array of `%T', which is an abstract class type",
7121 return error_mark_node;
7124 r = build_cplus_array_type (type, domain);
7131 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7132 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7134 if (e1 == error_mark_node || e2 == error_mark_node)
7135 return error_mark_node;
7137 return fold (build (TREE_CODE (t), TREE_TYPE (t), e1, e2));
7143 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7144 if (e == error_mark_node)
7145 return error_mark_node;
7147 return fold (build (TREE_CODE (t), TREE_TYPE (t), e));
7152 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7153 in_decl, /*entering_scope=*/1);
7154 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7157 if (ctx == error_mark_node || f == error_mark_node)
7158 return error_mark_node;
7160 if (!IS_AGGR_TYPE (ctx))
7162 if (complain & tf_error)
7163 error ("`%T' is not a class, struct, or union type",
7165 return error_mark_node;
7167 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7169 /* Normally, make_typename_type does not require that the CTX
7170 have complete type in order to allow things like:
7172 template <class T> struct S { typename S<T>::X Y; };
7174 But, such constructs have already been resolved by this
7175 point, so here CTX really should have complete type, unless
7176 it's a partial instantiation. */
7177 ctx = complete_type (ctx);
7178 if (!COMPLETE_TYPE_P (ctx))
7180 if (complain & tf_error)
7181 cxx_incomplete_type_error (NULL_TREE, ctx);
7182 return error_mark_node;
7186 f = make_typename_type (ctx, f,
7187 (complain & tf_error) | tf_keep_type_decl);
7188 if (f == error_mark_node)
7190 if (TREE_CODE (f) == TYPE_DECL)
7192 complain |= tf_ignore_bad_quals;
7196 return cp_build_qualified_type_real
7197 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7200 case UNBOUND_CLASS_TEMPLATE:
7202 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7203 in_decl, /*entering_scope=*/1);
7204 tree name = TYPE_IDENTIFIER (t);
7206 if (ctx == error_mark_node || name == error_mark_node)
7207 return error_mark_node;
7209 return make_unbound_class_template (ctx, name, complain);
7214 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7215 if (e == error_mark_node)
7216 return error_mark_node;
7217 return make_pointer_declarator (type, e);
7222 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7223 if (e == error_mark_node)
7224 return error_mark_node;
7225 return make_reference_declarator (type, e);
7230 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7231 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl);
7232 if (e1 == error_mark_node || e2 == error_mark_node)
7233 return error_mark_node;
7235 return build_nt (ARRAY_REF, e1, e2);
7240 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7241 tree e2 = (tsubst_call_declarator_parms
7242 (CALL_DECLARATOR_PARMS (t), args, complain, in_decl));
7243 tree e3 = tsubst (CALL_DECLARATOR_EXCEPTION_SPEC (t), args,
7246 if (e1 == error_mark_node || e2 == error_mark_node
7247 || e3 == error_mark_node)
7248 return error_mark_node;
7250 return make_call_declarator (e1, e2, CALL_DECLARATOR_QUALS (t), e3);
7255 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7256 tree e2 = tsubst (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 (TREE_CODE (t), e1, e2);
7267 type = finish_typeof (tsubst_expr (TYPE_FIELDS (t), args, complain,
7269 return cp_build_qualified_type_real (type,
7271 | cp_type_quals (type),
7276 sorry ("use of `%s' in template",
7277 tree_code_name [(int) TREE_CODE (t)]);
7278 return error_mark_node;
7282 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7283 type of the expression on the left-hand side of the "." or "->"
7287 tsubst_baselink (tree baselink, tree object_type,
7288 tree args, tsubst_flags_t complain, tree in_decl)
7291 tree qualifying_scope;
7293 tree template_args = 0;
7294 bool template_id_p = false;
7296 /* A baselink indicates a function from a base class. The
7297 BASELINK_ACCESS_BINFO and BASELINK_BINFO are going to have
7298 non-dependent types; otherwise, the lookup could not have
7299 succeeded. However, they may indicate bases of the template
7300 class, rather than the instantiated class.
7302 In addition, lookups that were not ambiguous before may be
7303 ambiguous now. Therefore, we perform the lookup again. */
7304 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7305 fns = BASELINK_FUNCTIONS (baselink);
7306 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7308 template_id_p = true;
7309 template_args = TREE_OPERAND (fns, 1);
7310 fns = TREE_OPERAND (fns, 0);
7312 template_args = tsubst_template_args (template_args, args,
7315 name = DECL_NAME (get_first_fn (fns));
7316 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7317 if (BASELINK_P (baselink) && template_id_p)
7318 BASELINK_FUNCTIONS (baselink)
7319 = build_nt (TEMPLATE_ID_EXPR,
7320 BASELINK_FUNCTIONS (baselink),
7323 object_type = current_class_type;
7324 return adjust_result_of_qualified_name_lookup (baselink,
7329 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7330 true if the qualified-id will be a postfix-expression in-and-of
7331 itself; false if more of the postfix-expression follows the
7332 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7336 tsubst_qualified_id (tree qualified_id, tree args,
7337 tsubst_flags_t complain, tree in_decl,
7338 bool done, bool address_p)
7346 my_friendly_assert (TREE_CODE (qualified_id) == SCOPE_REF, 20030706);
7348 /* Figure out what name to look up. */
7349 name = TREE_OPERAND (qualified_id, 1);
7350 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7353 template_args = TREE_OPERAND (name, 1);
7355 template_args = tsubst_template_args (template_args, args,
7357 name = TREE_OPERAND (name, 0);
7361 is_template = false;
7362 template_args = NULL_TREE;
7365 /* Substitute into the qualifying scope. When there are no ARGS, we
7366 are just trying to simplify a non-dependent expression. In that
7367 case the qualifying scope may be dependent, and, in any case,
7368 substituting will not help. */
7369 scope = TREE_OPERAND (qualified_id, 0);
7372 scope = tsubst (scope, args, complain, in_decl);
7373 expr = tsubst_copy (name, args, complain, in_decl);
7378 if (dependent_type_p (scope))
7379 return build_nt (SCOPE_REF, scope, expr);
7381 if (!BASELINK_P (name) && !DECL_P (expr))
7383 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7384 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7385 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7387 if (complain & tf_error)
7389 error ("dependent-name `%E' is parsed as a non-type, but "
7390 "instantiation yields a type", qualified_id);
7391 inform ("say `typename %E' if a type is meant", qualified_id);
7393 return error_mark_node;
7398 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7401 /* Remember that there was a reference to this entity. */
7406 expr = lookup_template_function (expr, template_args);
7408 if (expr == error_mark_node && complain & tf_error)
7409 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1));
7410 else if (TYPE_P (scope))
7412 expr = (adjust_result_of_qualified_name_lookup
7413 (expr, scope, current_class_type));
7414 expr = finish_qualified_id_expr (scope, expr, done, address_p);
7420 /* Like tsubst, but deals with expressions. This function just replaces
7421 template parms; to finish processing the resultant expression, use
7425 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7427 enum tree_code code;
7430 if (t == NULL_TREE || t == error_mark_node)
7433 code = TREE_CODE (t);
7438 r = retrieve_local_specialization (t);
7439 my_friendly_assert (r != NULL, 20020903);
7448 if (DECL_TEMPLATE_PARM_P (t))
7449 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
7450 /* There is no need to substitute into namespace-scope
7452 if (DECL_NAMESPACE_SCOPE_P (t))
7454 /* If ARGS is NULL, then T is known to be non-dependent. */
7455 if (args == NULL_TREE)
7456 return decl_constant_value (t);
7458 /* Unfortunately, we cannot just call lookup_name here.
7461 template <int I> int f() {
7463 struct S { void g() { E e = a; } };
7466 When we instantiate f<7>::S::g(), say, lookup_name is not
7467 clever enough to find f<7>::a. */
7469 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
7470 /*entering_scope=*/0);
7472 for (v = TYPE_VALUES (enum_type);
7475 if (TREE_PURPOSE (v) == DECL_NAME (t))
7476 return TREE_VALUE (v);
7478 /* We didn't find the name. That should never happen; if
7479 name-lookup found it during preliminary parsing, we
7480 should find it again here during instantiation. */
7486 if (DECL_CONTEXT (t))
7490 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
7491 /*entering_scope=*/1);
7492 if (ctx != DECL_CONTEXT (t))
7494 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
7497 if (complain & tf_error)
7498 error ("using invalid field `%D'", t);
7499 return error_mark_node;
7508 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
7509 || local_variable_p (t))
7510 t = tsubst (t, args, complain, in_decl);
7515 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
7518 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7519 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
7520 args, complain, in_decl);
7521 else if (is_member_template (t))
7522 return tsubst (t, args, complain, in_decl);
7523 else if (DECL_CLASS_SCOPE_P (t)
7524 && uses_template_parms (DECL_CONTEXT (t)))
7526 /* Template template argument like the following example need
7529 template <template <class> class TT> struct C {};
7530 template <class T> struct D {
7531 template <class U> struct E {};
7536 We are processing the template argument `E' in #1 for
7537 the template instantiation #2. Originally, `E' is a
7538 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
7539 have to substitute this with one having context `D<int>'. */
7541 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
7542 return lookup_field (context, DECL_NAME(t), 0, false);
7545 /* Ordinary template template argument. */
7549 case REINTERPRET_CAST_EXPR:
7550 case CONST_CAST_EXPR:
7551 case STATIC_CAST_EXPR:
7552 case DYNAMIC_CAST_EXPR:
7555 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7556 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7560 case TRUTH_NOT_EXPR:
7563 case CONVERT_EXPR: /* Unary + */
7572 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7573 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7580 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
7581 name = TREE_OPERAND (t, 1);
7582 if (TREE_CODE (name) == BIT_NOT_EXPR)
7584 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7586 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7588 else if (TREE_CODE (name) == SCOPE_REF
7589 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
7591 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
7593 name = TREE_OPERAND (name, 1);
7594 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7596 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7597 name = build_nt (SCOPE_REF, base, name);
7599 else if (TREE_CODE (name) == BASELINK)
7600 name = tsubst_baselink (name,
7601 non_reference (TREE_TYPE (object)),
7605 name = tsubst_copy (name, args, complain, in_decl);
7606 return build_nt (COMPONENT_REF, object, name);
7612 case TRUNC_DIV_EXPR:
7614 case FLOOR_DIV_EXPR:
7615 case ROUND_DIV_EXPR:
7616 case EXACT_DIV_EXPR:
7620 case TRUNC_MOD_EXPR:
7621 case FLOOR_MOD_EXPR:
7622 case TRUTH_ANDIF_EXPR:
7623 case TRUTH_ORIF_EXPR:
7624 case TRUTH_AND_EXPR:
7643 case PREDECREMENT_EXPR:
7644 case PREINCREMENT_EXPR:
7645 case POSTDECREMENT_EXPR:
7646 case POSTINCREMENT_EXPR:
7648 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7649 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7652 return build_nt (code,
7653 tsubst_copy (TREE_OPERAND (t, 0), args,
7655 tsubst_copy (TREE_OPERAND (t, 1), args, complain,
7660 /* This processing should really occur in tsubst_expr. However,
7661 tsubst_expr does not recurse into expressions, since it
7662 assumes that there aren't any statements inside them. So, we
7663 need to expand the STMT_EXPR here. */
7664 if (!processing_template_decl)
7666 tree stmt_expr = begin_stmt_expr ();
7668 tsubst_expr (STMT_EXPR_STMT (t), args,
7669 complain | tf_stmt_expr_cmpd, in_decl);
7670 return finish_stmt_expr (stmt_expr, false);
7677 case PSEUDO_DTOR_EXPR:
7680 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7681 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7682 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7689 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7690 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7691 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7692 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
7699 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7700 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7701 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
7702 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
7706 case TEMPLATE_ID_EXPR:
7708 /* Substituted template arguments */
7709 tree fn = TREE_OPERAND (t, 0);
7710 tree targs = TREE_OPERAND (t, 1);
7712 fn = tsubst_copy (fn, args, complain, in_decl);
7714 targs = tsubst_template_args (targs, args, complain, in_decl);
7716 return lookup_template_function (fn, targs);
7721 tree purpose, value, chain;
7723 if (t == void_list_node)
7726 purpose = TREE_PURPOSE (t);
7728 purpose = tsubst_copy (purpose, args, complain, in_decl);
7729 value = TREE_VALUE (t);
7731 value = tsubst_copy (value, args, complain, in_decl);
7732 chain = TREE_CHAIN (t);
7733 if (chain && chain != void_type_node)
7734 chain = tsubst_copy (chain, args, complain, in_decl);
7735 if (purpose == TREE_PURPOSE (t)
7736 && value == TREE_VALUE (t)
7737 && chain == TREE_CHAIN (t))
7739 return tree_cons (purpose, value, chain);
7746 case TEMPLATE_TYPE_PARM:
7747 case TEMPLATE_TEMPLATE_PARM:
7748 case BOUND_TEMPLATE_TEMPLATE_PARM:
7749 case TEMPLATE_PARM_INDEX:
7751 case REFERENCE_TYPE:
7757 case UNBOUND_CLASS_TEMPLATE:
7760 return tsubst (t, args, complain, in_decl);
7762 case IDENTIFIER_NODE:
7763 if (IDENTIFIER_TYPENAME_P (t))
7765 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7766 return mangle_conv_op_name_for_type (new_type);
7773 r = build_constructor
7774 (tsubst (TREE_TYPE (t), args, complain, in_decl),
7775 tsubst_copy (CONSTRUCTOR_ELTS (t), args, complain, in_decl));
7776 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
7781 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
7783 tsubst (TREE_TYPE (t), args, complain, in_decl));
7790 /* Like tsubst_copy for expressions, etc. but also does semantic
7794 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7797 tsubst_flags_t stmt_expr
7798 = complain & (tf_stmt_expr_cmpd | tf_stmt_expr_body);
7800 complain ^= stmt_expr;
7801 if (t == NULL_TREE || t == error_mark_node)
7804 if (!STATEMENT_CODE_P (TREE_CODE (t)))
7805 return tsubst_copy_and_build (t, args, complain, in_decl,
7806 /*function_p=*/false);
7808 switch (TREE_CODE (t))
7810 case CTOR_INITIALIZER:
7812 finish_mem_initializers (tsubst_initializer_list
7813 (TREE_OPERAND (t, 0), args));
7818 finish_return_stmt (tsubst_expr (RETURN_STMT_EXPR (t),
7819 args, complain, in_decl));
7828 r = tsubst_expr (EXPR_STMT_EXPR (t), args, complain, in_decl);
7829 if (stmt_expr & tf_stmt_expr_body && !TREE_CHAIN (t))
7830 finish_stmt_expr_expr (r);
7832 finish_expr_stmt (r);
7838 do_using_directive (tsubst_expr (USING_STMT_NAMESPACE (t),
7839 args, complain, in_decl));
7848 decl = DECL_STMT_DECL (t);
7849 if (TREE_CODE (decl) == LABEL_DECL)
7850 finish_label_decl (DECL_NAME (decl));
7851 else if (TREE_CODE (decl) == USING_DECL)
7853 tree scope = DECL_INITIAL (decl);
7854 tree name = DECL_NAME (decl);
7857 scope = tsubst_expr (scope, args, complain, in_decl);
7858 decl = lookup_qualified_name (scope, name,
7859 /*is_type_p=*/false,
7860 /*complain=*/false);
7861 if (decl == error_mark_node)
7862 qualified_name_lookup_error (scope, name);
7864 do_local_using_decl (decl, scope, name);
7868 init = DECL_INITIAL (decl);
7869 decl = tsubst (decl, args, complain, in_decl);
7870 if (decl != error_mark_node)
7873 DECL_INITIAL (decl) = error_mark_node;
7874 /* By marking the declaration as instantiated, we avoid
7875 trying to instantiate it. Since instantiate_decl can't
7876 handle local variables, and since we've already done
7877 all that needs to be done, that's the right thing to
7879 if (TREE_CODE (decl) == VAR_DECL)
7880 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
7881 if (TREE_CODE (decl) == VAR_DECL
7882 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
7883 /* Anonymous aggregates are a special case. */
7884 finish_anon_union (decl);
7887 maybe_push_decl (decl);
7888 if (TREE_CODE (decl) == VAR_DECL
7889 && DECL_PRETTY_FUNCTION_P (decl))
7891 /* For __PRETTY_FUNCTION__ we have to adjust the
7893 const char *const name
7894 = cxx_printable_name (current_function_decl, 2);
7895 init = cp_fname_init (name, &TREE_TYPE (decl));
7898 init = tsubst_expr (init, args, complain, in_decl);
7899 cp_finish_decl (decl, init, NULL_TREE, 0);
7904 /* A DECL_STMT can also be used as an expression, in the condition
7905 clause of an if/for/while construct. If we aren't followed by
7906 another statement, return our decl. */
7907 if (TREE_CHAIN (t) == NULL_TREE)
7916 stmt = begin_for_stmt ();
7917 tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl);
7918 finish_for_init_stmt (stmt);
7919 finish_for_cond (tsubst_expr (FOR_COND (t),
7920 args, complain, in_decl),
7922 tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
7923 finish_for_expr (tmp, stmt);
7924 tsubst_expr (FOR_BODY (t), args, complain, in_decl);
7925 finish_for_stmt (stmt);
7932 stmt = begin_while_stmt ();
7933 finish_while_stmt_cond (tsubst_expr (WHILE_COND (t),
7934 args, complain, in_decl),
7936 tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
7937 finish_while_stmt (stmt);
7944 stmt = begin_do_stmt ();
7945 tsubst_expr (DO_BODY (t), args, complain, in_decl);
7946 finish_do_body (stmt);
7947 finish_do_stmt (tsubst_expr (DO_COND (t),
7948 args, complain, in_decl),
7956 stmt = begin_if_stmt ();
7957 finish_if_stmt_cond (tsubst_expr (IF_COND (t),
7958 args, complain, in_decl),
7961 if (tmp = THEN_CLAUSE (t), tmp)
7963 tsubst_expr (tmp, args, complain, in_decl);
7964 finish_then_clause (stmt);
7967 if (tmp = ELSE_CLAUSE (t), tmp)
7969 begin_else_clause ();
7970 tsubst_expr (tmp, args, complain, in_decl);
7971 finish_else_clause (stmt);
7981 if (COMPOUND_STMT_BODY_BLOCK (t))
7982 stmt = begin_function_body ();
7984 stmt = begin_compound_stmt (COMPOUND_STMT_NO_SCOPE (t));
7986 tsubst_expr (COMPOUND_BODY (t), args,
7987 complain | ((stmt_expr & tf_stmt_expr_cmpd) << 1),
7990 if (COMPOUND_STMT_BODY_BLOCK (t))
7991 finish_function_body (stmt);
7993 finish_compound_stmt (stmt);
7999 finish_break_stmt ();
8004 finish_continue_stmt ();
8012 stmt = begin_switch_stmt ();
8013 val = tsubst_expr (SWITCH_COND (t), args, complain, in_decl);
8014 finish_switch_cond (val, stmt);
8015 tsubst_expr (SWITCH_BODY (t), args, complain, in_decl);
8016 finish_switch_stmt (stmt);
8022 finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl),
8023 tsubst_expr (CASE_HIGH (t), args, complain,
8028 input_line = STMT_LINENO (t);
8029 finish_label_stmt (DECL_NAME (LABEL_STMT_LABEL (t)));
8033 input_filename = FILE_STMT_FILENAME (t);
8034 add_stmt (build_nt (FILE_STMT, FILE_STMT_FILENAME_NODE (t)));
8039 tmp = GOTO_DESTINATION (t);
8040 if (TREE_CODE (tmp) != LABEL_DECL)
8041 /* Computed goto's must be tsubst'd into. On the other hand,
8042 non-computed gotos must not be; the identifier in question
8043 will have no binding. */
8044 tmp = tsubst_expr (tmp, args, complain, in_decl);
8046 tmp = DECL_NAME (tmp);
8047 finish_goto_stmt (tmp);
8052 tmp = finish_asm_stmt
8054 tsubst_expr (ASM_STRING (t), args, complain, in_decl),
8055 tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl),
8056 tsubst_expr (ASM_INPUTS (t), args, complain, in_decl),
8057 tsubst_expr (ASM_CLOBBERS (t), args, complain, in_decl));
8058 ASM_INPUT_P (tmp) = ASM_INPUT_P (t);
8065 stmt = begin_try_block ();
8066 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
8067 finish_cleanup_try_block (stmt);
8068 finish_cleanup (tsubst_expr (TRY_HANDLERS (t), args,
8074 if (FN_TRY_BLOCK_P (t))
8075 stmt = begin_function_try_block ();
8077 stmt = begin_try_block ();
8079 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
8081 if (FN_TRY_BLOCK_P (t))
8082 finish_function_try_block (stmt);
8084 finish_try_block (stmt);
8086 tsubst_expr (TRY_HANDLERS (t), args, complain, in_decl);
8087 if (FN_TRY_BLOCK_P (t))
8088 finish_function_handler_sequence (stmt);
8090 finish_handler_sequence (stmt);
8099 stmt = begin_handler ();
8100 if (HANDLER_PARMS (t))
8102 decl = DECL_STMT_DECL (HANDLER_PARMS (t));
8103 decl = tsubst (decl, args, complain, in_decl);
8104 /* Prevent instantiate_decl from trying to instantiate
8105 this variable. We've already done all that needs to be
8107 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8111 finish_handler_parms (decl, stmt);
8112 tsubst_expr (HANDLER_BODY (t), args, complain, in_decl);
8113 finish_handler (stmt);
8119 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8126 return tsubst_expr (TREE_CHAIN (t), args, complain | stmt_expr, in_decl);
8129 /* T is a postfix-expression that is not being used in a function
8130 call. Return the substituted version of T. */
8133 tsubst_non_call_postfix_expression (tree t, tree args,
8134 tsubst_flags_t complain,
8137 if (TREE_CODE (t) == SCOPE_REF)
8138 t = tsubst_qualified_id (t, args, complain, in_decl,
8139 /*done=*/false, /*address_p=*/false);
8141 t = tsubst_copy_and_build (t, args, complain, in_decl,
8142 /*function_p=*/false);
8147 /* Like tsubst but deals with expressions and performs semantic
8148 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8151 tsubst_copy_and_build (tree t,
8153 tsubst_flags_t complain,
8157 #define RECUR(NODE) \
8158 tsubst_copy_and_build (NODE, args, complain, in_decl, /*function_p=*/false)
8162 if (t == NULL_TREE || t == error_mark_node)
8165 switch (TREE_CODE (t))
8170 case IDENTIFIER_NODE:
8174 tree qualifying_class;
8175 bool non_integral_constant_expression_p;
8176 const char *error_msg;
8178 if (IDENTIFIER_TYPENAME_P (t))
8180 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8181 t = mangle_conv_op_name_for_type (new_type);
8184 /* Look up the name. */
8185 decl = lookup_name (t, 0);
8187 /* By convention, expressions use ERROR_MARK_NODE to indicate
8188 failure, not NULL_TREE. */
8189 if (decl == NULL_TREE)
8190 decl = error_mark_node;
8192 decl = finish_id_expression (t, decl, NULL_TREE,
8195 /*integral_constant_expression_p=*/false,
8196 /*allow_non_integral_constant_expression_p=*/false,
8197 &non_integral_constant_expression_p,
8201 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8202 decl = unqualified_name_lookup_error (decl);
8206 case TEMPLATE_ID_EXPR:
8209 tree template = RECUR (TREE_OPERAND (t, 0));
8210 tree targs = TREE_OPERAND (t, 1);
8213 targs = tsubst_template_args (targs, args, complain, in_decl);
8215 if (TREE_CODE (template) == COMPONENT_REF)
8217 object = TREE_OPERAND (template, 0);
8218 template = TREE_OPERAND (template, 1);
8222 template = lookup_template_function (template, targs);
8225 return build (COMPONENT_REF, TREE_TYPE (template),
8232 return build_x_indirect_ref (RECUR (TREE_OPERAND (t, 0)), "unary *");
8236 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8237 RECUR (TREE_OPERAND (t, 0)));
8240 return build_functional_cast
8241 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8242 RECUR (TREE_OPERAND (t, 0)));
8244 case REINTERPRET_CAST_EXPR:
8245 return build_reinterpret_cast
8246 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8247 RECUR (TREE_OPERAND (t, 0)));
8249 case CONST_CAST_EXPR:
8250 return build_const_cast
8251 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8252 RECUR (TREE_OPERAND (t, 0)));
8254 case DYNAMIC_CAST_EXPR:
8255 return build_dynamic_cast
8256 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8257 RECUR (TREE_OPERAND (t, 0)));
8259 case STATIC_CAST_EXPR:
8260 return build_static_cast
8261 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8262 RECUR (TREE_OPERAND (t, 0)));
8264 case POSTDECREMENT_EXPR:
8265 case POSTINCREMENT_EXPR:
8266 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8267 args, complain, in_decl);
8268 return build_x_unary_op (TREE_CODE (t), op1);
8270 case PREDECREMENT_EXPR:
8271 case PREINCREMENT_EXPR:
8275 case TRUTH_NOT_EXPR:
8276 case CONVERT_EXPR: /* Unary + */
8279 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
8282 op1 = TREE_OPERAND (t, 0);
8283 if (TREE_CODE (op1) == SCOPE_REF)
8284 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
8285 /*done=*/true, /*address_p=*/true);
8287 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
8289 if (TREE_CODE (op1) == LABEL_DECL)
8290 return finish_label_address_expr (DECL_NAME (op1));
8291 return build_x_unary_op (ADDR_EXPR, op1);
8296 case TRUNC_DIV_EXPR:
8298 case FLOOR_DIV_EXPR:
8299 case ROUND_DIV_EXPR:
8300 case EXACT_DIV_EXPR:
8304 case TRUNC_MOD_EXPR:
8305 case FLOOR_MOD_EXPR:
8306 case TRUTH_ANDIF_EXPR:
8307 case TRUTH_ORIF_EXPR:
8308 case TRUTH_AND_EXPR:
8324 return build_x_binary_op
8326 RECUR (TREE_OPERAND (t, 0)),
8327 RECUR (TREE_OPERAND (t, 1)),
8328 /*overloaded_p=*/NULL);
8331 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
8332 /*address_p=*/false);
8335 if (tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl)
8338 return build_nt (ARRAY_REF, NULL_TREE, RECUR (TREE_OPERAND (t, 1)));
8340 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8341 args, complain, in_decl);
8342 /* Remember that there was a reference to this entity. */
8345 return grok_array_decl (op1, RECUR (TREE_OPERAND (t, 1)));
8349 op1 = TREE_OPERAND (t, 0);
8352 /* When there are no ARGS, we are trying to evaluate a
8353 non-dependent expression from the parser. Trying to do
8354 the substitutions may not work. */
8356 op1 = TREE_TYPE (op1);
8365 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
8367 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
8370 return build_x_modify_expr
8371 (RECUR (TREE_OPERAND (t, 0)),
8372 TREE_CODE (TREE_OPERAND (t, 1)),
8373 RECUR (TREE_OPERAND (t, 2)));
8376 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8377 args, complain, in_decl);
8378 /* Remember that there was a reference to this entity. */
8381 return build_x_arrow (op1);
8385 (RECUR (TREE_OPERAND (t, 0)),
8386 RECUR (TREE_OPERAND (t, 1)),
8387 RECUR (TREE_OPERAND (t, 2)),
8388 NEW_EXPR_USE_GLOBAL (t));
8391 return delete_sanity
8392 (RECUR (TREE_OPERAND (t, 0)),
8393 RECUR (TREE_OPERAND (t, 1)),
8394 DELETE_EXPR_USE_VEC (t),
8395 DELETE_EXPR_USE_GLOBAL (t));
8398 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
8399 RECUR (TREE_OPERAND (t, 1)));
8408 function = TREE_OPERAND (t, 0);
8409 /* When we parsed the expression, we determined whether or
8410 not Koenig lookup should be performed. */
8411 koenig_p = KOENIG_LOOKUP_P (t);
8412 if (TREE_CODE (function) == SCOPE_REF)
8415 function = tsubst_qualified_id (function, args, complain, in_decl,
8417 /*address_p=*/false);
8421 qualified_p = (TREE_CODE (function) == COMPONENT_REF
8422 && (TREE_CODE (TREE_OPERAND (function, 1))
8424 function = tsubst_copy_and_build (function, args, complain,
8427 if (BASELINK_P (function))
8431 call_args = RECUR (TREE_OPERAND (t, 1));
8433 /* We do not perform argument-dependent lookup if normal
8434 lookup finds a non-function, in accordance with the
8435 expected resolution of DR 218. */
8437 && ((is_overloaded_fn (function)
8438 /* If lookup found a member function, the Koenig lookup is
8439 not appropriate, even if an unqualified-name was used
8440 to denote the function. */
8441 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
8442 || TREE_CODE (function) == IDENTIFIER_NODE))
8443 function = perform_koenig_lookup (function, call_args);
8445 if (TREE_CODE (function) == IDENTIFIER_NODE)
8447 unqualified_name_lookup_error (function);
8448 return error_mark_node;
8451 /* Remember that there was a reference to this entity. */
8452 if (DECL_P (function))
8453 mark_used (function);
8455 function = convert_from_reference (function);
8457 if (TREE_CODE (function) == OFFSET_REF)
8458 return build_offset_ref_call_from_tree (function, call_args);
8459 if (TREE_CODE (function) == COMPONENT_REF)
8461 if (!BASELINK_P (TREE_OPERAND (function, 1)))
8462 return finish_call_expr (function, call_args,
8463 /*disallow_virtual=*/false,
8464 /*koenig_p=*/false);
8466 return (build_new_method_call
8467 (TREE_OPERAND (function, 0),
8468 TREE_OPERAND (function, 1),
8469 call_args, NULL_TREE,
8470 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL));
8472 return finish_call_expr (function, call_args,
8473 /*disallow_virtual=*/qualified_p,
8478 return build_x_conditional_expr
8479 (RECUR (TREE_OPERAND (t, 0)),
8480 RECUR (TREE_OPERAND (t, 1)),
8481 RECUR (TREE_OPERAND (t, 2)));
8483 case PSEUDO_DTOR_EXPR:
8484 return finish_pseudo_destructor_expr
8485 (RECUR (TREE_OPERAND (t, 0)),
8486 RECUR (TREE_OPERAND (t, 1)),
8487 RECUR (TREE_OPERAND (t, 2)));
8491 tree purpose, value, chain;
8493 if (t == void_list_node)
8496 purpose = TREE_PURPOSE (t);
8498 purpose = RECUR (purpose);
8499 value = TREE_VALUE (t);
8501 value = RECUR (value);
8502 chain = TREE_CHAIN (t);
8503 if (chain && chain != void_type_node)
8504 chain = RECUR (chain);
8505 if (purpose == TREE_PURPOSE (t)
8506 && value == TREE_VALUE (t)
8507 && chain == TREE_CHAIN (t))
8509 return tree_cons (purpose, value, chain);
8517 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8518 args, complain, in_decl);
8519 /* Remember that there was a reference to this entity. */
8520 if (DECL_P (object))
8523 member = TREE_OPERAND (t, 1);
8524 if (BASELINK_P (member))
8525 member = tsubst_baselink (member,
8526 non_reference (TREE_TYPE (object)),
8527 args, complain, in_decl);
8529 member = tsubst_copy (member, args, complain, in_decl);
8531 if (member == error_mark_node)
8532 return error_mark_node;
8533 else if (!CLASS_TYPE_P (TREE_TYPE (object)))
8535 if (TREE_CODE (member) == BIT_NOT_EXPR)
8536 return finish_pseudo_destructor_expr (object,
8538 TREE_TYPE (object));
8539 else if (TREE_CODE (member) == SCOPE_REF
8540 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
8541 return finish_pseudo_destructor_expr (object,
8543 TREE_TYPE (object));
8545 else if (TREE_CODE (member) == SCOPE_REF
8546 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
8551 /* Lookup the template functions now that we know what the
8553 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
8554 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
8555 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
8556 /*is_type_p=*/false,
8557 /*complain=*/false);
8558 if (BASELINK_P (member))
8560 BASELINK_FUNCTIONS (member)
8561 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
8563 member = (adjust_result_of_qualified_name_lookup
8564 (member, BINFO_TYPE (BASELINK_BINFO (member)),
8565 TREE_TYPE (object)));
8569 qualified_name_lookup_error (TREE_TYPE (object), tmpl);
8570 return error_mark_node;
8573 else if (TREE_CODE (member) == SCOPE_REF
8574 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
8575 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
8577 if (complain & tf_error)
8579 if (TYPE_P (TREE_OPERAND (member, 0)))
8580 error ("`%T' is not a class or namespace",
8581 TREE_OPERAND (member, 0));
8583 error ("`%D' is not a class or namespace",
8584 TREE_OPERAND (member, 0));
8586 return error_mark_node;
8588 else if (TREE_CODE (member) == FIELD_DECL)
8589 return finish_non_static_data_member (member, object, NULL_TREE);
8591 return finish_class_member_access_expr (object, member);
8596 (RECUR (TREE_OPERAND (t, 0)));
8602 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8605 /* digest_init will do the wrong thing if we let it. */
8606 if (type && TYPE_PTRMEMFUNC_P (type))
8610 /* We do not want to process the purpose of aggregate
8611 initializers as they are identifier nodes which will be
8612 looked up by digest_init. */
8613 purpose_p = !(type && IS_AGGR_TYPE (type));
8614 for (elts = CONSTRUCTOR_ELTS (t);
8616 elts = TREE_CHAIN (elts))
8618 tree purpose = TREE_PURPOSE (elts);
8619 tree value = TREE_VALUE (elts);
8621 if (purpose && purpose_p)
8622 purpose = RECUR (purpose);
8623 value = RECUR (value);
8624 r = tree_cons (purpose, value, r);
8627 r = build_constructor (NULL_TREE, nreverse (r));
8628 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
8631 return digest_init (type, r, 0);
8637 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
8638 if (TYPE_P (operand_0))
8639 return get_typeid (operand_0);
8640 return build_typeid (operand_0);
8644 return convert_from_reference (tsubst_copy (t, args, complain, in_decl));
8648 t = tsubst_copy (t, args, complain, in_decl);
8649 return convert_from_reference (t);
8652 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
8653 tsubst_copy (TREE_TYPE (t), args, complain,
8657 t = tsubst_copy (t, args, complain, in_decl);
8658 /* As in finish_id_expression, we resolve enumeration constants
8659 to their underlying values. */
8660 if (TREE_CODE (t) == CONST_DECL)
8661 return DECL_INITIAL (t);
8665 return tsubst_copy (t, args, complain, in_decl);
8671 /* Verify that the instantiated ARGS are valid. For type arguments,
8672 make sure that the type's linkage is ok. For non-type arguments,
8673 make sure they are constants if they are integral or enumerations.
8674 Emit an error under control of COMPLAIN, and return TRUE on error. */
8677 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
8679 int ix, len = DECL_NTPARMS (tmpl);
8680 bool result = false;
8682 for (ix = 0; ix != len; ix++)
8684 tree t = TREE_VEC_ELT (args, ix);
8688 /* [basic.link]: A name with no linkage (notably, the name
8689 of a class or enumeration declared in a local scope)
8690 shall not be used to declare an entity with linkage.
8691 This implies that names with no linkage cannot be used as
8692 template arguments. */
8693 tree nt = no_linkage_check (t);
8697 if (!(complain & tf_error))
8699 else if (TYPE_ANONYMOUS_P (nt))
8700 error ("`%T' uses anonymous type", t);
8702 error ("`%T' uses local type `%T'", t, nt);
8705 /* In order to avoid all sorts of complications, we do not
8706 allow variably-modified types as template arguments. */
8707 else if (variably_modified_type_p (t))
8709 if (complain & tf_error)
8710 error ("`%T' is a variably modified type", t);
8714 /* A non-type argument of integral or enumerated type must be a
8716 else if (TREE_TYPE (t)
8717 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
8718 && !TREE_CONSTANT (t))
8720 if (complain & tf_error)
8721 error ("integral expression `%E' is not constant", t);
8725 if (result && complain & tf_error)
8726 error (" trying to instantiate `%D'", tmpl);
8730 /* Instantiate the indicated variable or function template TMPL with
8731 the template arguments in TARG_PTR. */
8734 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
8740 if (tmpl == error_mark_node)
8741 return error_mark_node;
8743 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 283);
8745 /* If this function is a clone, handle it specially. */
8746 if (DECL_CLONED_FUNCTION_P (tmpl))
8751 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
8753 if (spec == error_mark_node)
8754 return error_mark_node;
8756 /* Look for the clone. */
8757 for (clone = TREE_CHAIN (spec);
8758 clone && DECL_CLONED_FUNCTION_P (clone);
8759 clone = TREE_CHAIN (clone))
8760 if (DECL_NAME (clone) == DECL_NAME (tmpl))
8762 /* We should always have found the clone by now. */
8767 /* Check to see if we already have this specialization. */
8768 spec = retrieve_specialization (tmpl, targ_ptr);
8769 if (spec != NULL_TREE)
8772 gen_tmpl = most_general_template (tmpl);
8773 if (tmpl != gen_tmpl)
8775 /* The TMPL is a partial instantiation. To get a full set of
8776 arguments we must add the arguments used to perform the
8777 partial instantiation. */
8778 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
8781 /* Check to see if we already have this specialization. */
8782 spec = retrieve_specialization (gen_tmpl, targ_ptr);
8783 if (spec != NULL_TREE)
8787 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
8789 return error_mark_node;
8791 /* We are building a FUNCTION_DECL, during which the access of its
8792 parameters and return types have to be checked. However this
8793 FUNCTION_DECL which is the desired context for access checking
8794 is not built yet. We solve this chicken-and-egg problem by
8795 deferring all checks until we have the FUNCTION_DECL. */
8796 push_deferring_access_checks (dk_deferred);
8798 /* Substitute template parameters. */
8799 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
8800 targ_ptr, complain, gen_tmpl);
8802 /* Now we know the specialization, compute access previously
8804 push_access_scope (fndecl);
8805 perform_deferred_access_checks ();
8806 pop_access_scope (fndecl);
8807 pop_deferring_access_checks ();
8809 /* The DECL_TI_TEMPLATE should always be the immediate parent
8810 template, not the most general template. */
8811 DECL_TI_TEMPLATE (fndecl) = tmpl;
8813 /* If we've just instantiated the main entry point for a function,
8814 instantiate all the alternate entry points as well. We do this
8815 by cloning the instantiation of the main entry point, not by
8816 instantiating the template clones. */
8817 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
8818 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
8823 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
8824 arguments that are being used when calling it. TARGS is a vector
8825 into which the deduced template arguments are placed.
8827 Return zero for success, 2 for an incomplete match that doesn't resolve
8828 all the types, and 1 for complete failure. An error message will be
8829 printed only for an incomplete match.
8831 If FN is a conversion operator, or we are trying to produce a specific
8832 specialization, RETURN_TYPE is the return type desired.
8834 The EXPLICIT_TARGS are explicit template arguments provided via a
8837 The parameter STRICT is one of:
8840 We are deducing arguments for a function call, as in
8844 We are deducing arguments for a conversion function, as in
8848 We are deducing arguments when doing an explicit instantiation
8849 as in [temp.explicit], when determining an explicit specialization
8850 as in [temp.expl.spec], or when taking the address of a function
8851 template, as in [temp.deduct.funcaddr].
8854 We are deducing arguments when calculating the partial
8855 ordering between specializations of function or class
8856 templates, as in [temp.func.order] and [temp.class.order].
8858 LEN is the number of parms to consider before returning success, or -1
8859 for all. This is used in partial ordering to avoid comparing parms for
8860 which no actual argument was passed, since they are not considered in
8861 overload resolution (and are explicitly excluded from consideration in
8862 partial ordering in [temp.func.order]/6). */
8865 fn_type_unification (tree fn,
8866 tree explicit_targs,
8870 unification_kind_t strict,
8877 my_friendly_assert (TREE_CODE (fn) == TEMPLATE_DECL, 0);
8879 fntype = TREE_TYPE (fn);
8884 The specified template arguments must match the template
8885 parameters in kind (i.e., type, nontype, template), and there
8886 must not be more arguments than there are parameters;
8887 otherwise type deduction fails.
8889 Nontype arguments must match the types of the corresponding
8890 nontype template parameters, or must be convertible to the
8891 types of the corresponding nontype parameters as specified in
8892 _temp.arg.nontype_, otherwise type deduction fails.
8894 All references in the function type of the function template
8895 to the corresponding template parameters are replaced by the
8896 specified template argument values. If a substitution in a
8897 template parameter or in the function type of the function
8898 template results in an invalid type, type deduction fails. */
8900 tree converted_args;
8903 if (explicit_targs == error_mark_node)
8907 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
8908 explicit_targs, NULL_TREE, tf_none,
8909 /*require_all_arguments=*/0));
8910 if (converted_args == error_mark_node)
8913 /* Substitute the explicit args into the function type. This is
8914 necessary so that, for instance, explicitly declared function
8915 arguments can match null pointed constants. If we were given
8916 an incomplete set of explicit args, we must not do semantic
8917 processing during substitution as we could create partial
8919 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
8920 processing_template_decl += incomplete;
8921 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
8922 processing_template_decl -= incomplete;
8924 if (fntype == error_mark_node)
8927 /* Place the explicitly specified arguments in TARGS. */
8928 for (i = NUM_TMPL_ARGS (converted_args); i--;)
8929 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
8932 parms = TYPE_ARG_TYPES (fntype);
8933 /* Never do unification on the 'this' parameter. */
8934 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
8935 parms = TREE_CHAIN (parms);
8939 /* We've been given a return type to match, prepend it. */
8940 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
8941 args = tree_cons (NULL_TREE, return_type, args);
8946 /* We allow incomplete unification without an error message here
8947 because the standard doesn't seem to explicitly prohibit it. Our
8948 callers must be ready to deal with unification failures in any
8950 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
8951 targs, parms, args, /*subr=*/0,
8952 strict, /*allow_incomplete*/1, len);
8955 /* All is well so far. Now, check:
8959 When all template arguments have been deduced, all uses of
8960 template parameters in nondeduced contexts are replaced with
8961 the corresponding deduced argument values. If the
8962 substitution results in an invalid type, as described above,
8963 type deduction fails. */
8964 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
8971 /* Adjust types before performing type deduction, as described in
8972 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
8973 sections are symmetric. PARM is the type of a function parameter
8974 or the return type of the conversion function. ARG is the type of
8975 the argument passed to the call, or the type of the value
8976 initialized with the result of the conversion function. */
8979 maybe_adjust_types_for_deduction (unification_kind_t strict,
8992 /* Swap PARM and ARG throughout the remainder of this
8993 function; the handling is precisely symmetric since PARM
8994 will initialize ARG rather than vice versa. */
9002 /* There is nothing to do in this case. */
9006 /* DR 214. [temp.func.order] is underspecified, and leads to no
9007 ordering between things like `T *' and `T const &' for `U *'.
9008 The former has T=U and the latter T=U*. The former looks more
9009 specialized and John Spicer considers it well-formed (the EDG
9010 compiler accepts it).
9012 John also confirms that deduction should proceed as in a function
9013 call. Which implies the usual ARG and PARM conversions as DEDUCE_CALL.
9014 However, in ordering, ARG can have REFERENCE_TYPE, but no argument
9015 to an actual call can have such a type.
9017 If both ARG and PARM are REFERENCE_TYPE, we change neither.
9018 If only ARG is a REFERENCE_TYPE, we look through that and then
9019 proceed as with DEDUCE_CALL (which could further convert it). */
9020 if (TREE_CODE (*arg) == REFERENCE_TYPE)
9022 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9024 *arg = TREE_TYPE (*arg);
9031 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9033 /* [temp.deduct.call]
9035 If P is not a reference type:
9037 --If A is an array type, the pointer type produced by the
9038 array-to-pointer standard conversion (_conv.array_) is
9039 used in place of A for type deduction; otherwise,
9041 --If A is a function type, the pointer type produced by
9042 the function-to-pointer standard conversion
9043 (_conv.func_) is used in place of A for type deduction;
9046 --If A is a cv-qualified type, the top level
9047 cv-qualifiers of A's type are ignored for type
9049 if (TREE_CODE (*arg) == ARRAY_TYPE)
9050 *arg = build_pointer_type (TREE_TYPE (*arg));
9051 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9052 *arg = build_pointer_type (*arg);
9054 *arg = TYPE_MAIN_VARIANT (*arg);
9057 /* [temp.deduct.call]
9059 If P is a cv-qualified type, the top level cv-qualifiers
9060 of P's type are ignored for type deduction. If P is a
9061 reference type, the type referred to by P is used for
9063 *parm = TYPE_MAIN_VARIANT (*parm);
9064 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9066 *parm = TREE_TYPE (*parm);
9067 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9070 /* DR 322. For conversion deduction, remove a reference type on parm
9071 too (which has been swapped into ARG). */
9072 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9073 *arg = TREE_TYPE (*arg);
9078 /* Most parms like fn_type_unification.
9080 If SUBR is 1, we're being called recursively (to unify the
9081 arguments of a function or method parameter of a function
9085 type_unification_real (tree tparms,
9090 unification_kind_t strict,
9091 int allow_incomplete,
9096 int ntparms = TREE_VEC_LENGTH (tparms);
9098 int saw_undeduced = 0;
9102 my_friendly_assert (TREE_CODE (tparms) == TREE_VEC, 289);
9103 my_friendly_assert (xparms == NULL_TREE
9104 || TREE_CODE (xparms) == TREE_LIST, 290);
9105 my_friendly_assert (!xargs || TREE_CODE (xargs) == TREE_LIST, 291);
9106 my_friendly_assert (ntparms > 0, 292);
9111 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9112 | UNIFY_ALLOW_DERIVED);
9116 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9120 sub_strict = UNIFY_ALLOW_NONE;
9124 sub_strict = UNIFY_ALLOW_NONE;
9140 && parms != void_list_node
9142 && args != void_list_node)
9144 parm = TREE_VALUE (parms);
9145 parms = TREE_CHAIN (parms);
9146 arg = TREE_VALUE (args);
9147 args = TREE_CHAIN (args);
9149 if (arg == error_mark_node)
9151 if (arg == unknown_type_node)
9152 /* We can't deduce anything from this, but we might get all the
9153 template args from other function args. */
9156 /* Conversions will be performed on a function argument that
9157 corresponds with a function parameter that contains only
9158 non-deducible template parameters and explicitly specified
9159 template parameters. */
9160 if (!uses_template_parms (parm))
9165 type = TREE_TYPE (arg);
9169 if (same_type_p (parm, type))
9171 if (strict != DEDUCE_EXACT
9172 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg))
9180 my_friendly_assert (TREE_TYPE (arg) != NULL_TREE, 293);
9181 if (type_unknown_p (arg))
9183 /* [temp.deduct.type] A template-argument can be deduced from
9184 a pointer to function or pointer to member function
9185 argument if the set of overloaded functions does not
9186 contain function templates and at most one of a set of
9187 overloaded functions provides a unique match. */
9189 if (resolve_overloaded_unification
9190 (tparms, targs, parm, arg, strict, sub_strict)
9195 arg = TREE_TYPE (arg);
9196 if (arg == error_mark_node)
9201 int arg_strict = sub_strict;
9204 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9206 if (unify (tparms, targs, parm, arg, arg_strict))
9210 /* Are we done with the interesting parms? */
9214 /* Fail if we've reached the end of the parm list, and more args
9215 are present, and the parm list isn't variadic. */
9216 if (args && args != void_list_node && parms == void_list_node)
9218 /* Fail if parms are left and they don't have default values. */
9220 && parms != void_list_node
9221 && TREE_PURPOSE (parms) == NULL_TREE)
9226 for (i = 0; i < ntparms; i++)
9227 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
9229 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
9231 /* If this is an undeduced nontype parameter that depends on
9232 a type parameter, try another pass; its type may have been
9233 deduced from a later argument than the one from which
9234 this parameter can be deduced. */
9235 if (TREE_CODE (tparm) == PARM_DECL
9236 && uses_template_parms (TREE_TYPE (tparm))
9237 && !saw_undeduced++)
9240 if (!allow_incomplete)
9241 error ("incomplete type unification");
9247 /* Subroutine of type_unification_real. Args are like the variables at the
9248 call site. ARG is an overloaded function (or template-id); we try
9249 deducing template args from each of the overloads, and if only one
9250 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
9253 resolve_overloaded_unification (tree tparms,
9257 unification_kind_t strict,
9260 tree tempargs = copy_node (targs);
9264 if (TREE_CODE (arg) == ADDR_EXPR)
9266 arg = TREE_OPERAND (arg, 0);
9272 if (TREE_CODE (arg) == COMPONENT_REF)
9273 /* Handle `&x' where `x' is some static or non-static member
9275 arg = TREE_OPERAND (arg, 1);
9277 if (TREE_CODE (arg) == OFFSET_REF)
9278 arg = TREE_OPERAND (arg, 1);
9280 /* Strip baselink information. */
9281 if (BASELINK_P (arg))
9282 arg = BASELINK_FUNCTIONS (arg);
9284 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
9286 /* If we got some explicit template args, we need to plug them into
9287 the affected templates before we try to unify, in case the
9288 explicit args will completely resolve the templates in question. */
9290 tree expl_subargs = TREE_OPERAND (arg, 1);
9291 arg = TREE_OPERAND (arg, 0);
9293 for (; arg; arg = OVL_NEXT (arg))
9295 tree fn = OVL_CURRENT (arg);
9298 if (TREE_CODE (fn) != TEMPLATE_DECL)
9301 subargs = get_bindings_overload (fn, DECL_TEMPLATE_RESULT (fn),
9305 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
9306 good += try_one_overload (tparms, targs, tempargs, parm,
9307 elem, strict, sub_strict, addr_p);
9311 else if (TREE_CODE (arg) == OVERLOAD
9312 || TREE_CODE (arg) == FUNCTION_DECL)
9314 for (; arg; arg = OVL_NEXT (arg))
9315 good += try_one_overload (tparms, targs, tempargs, parm,
9316 TREE_TYPE (OVL_CURRENT (arg)),
9317 strict, sub_strict, addr_p);
9322 /* [temp.deduct.type] A template-argument can be deduced from a pointer
9323 to function or pointer to member function argument if the set of
9324 overloaded functions does not contain function templates and at most
9325 one of a set of overloaded functions provides a unique match.
9327 So if we found multiple possibilities, we return success but don't
9332 int i = TREE_VEC_LENGTH (targs);
9334 if (TREE_VEC_ELT (tempargs, i))
9335 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
9343 /* Subroutine of resolve_overloaded_unification; does deduction for a single
9344 overload. Fills TARGS with any deduced arguments, or error_mark_node if
9345 different overloads deduce different arguments for a given parm.
9346 ADDR_P is true if the expression for which deduction is being
9347 performed was of the form "& fn" rather than simply "fn".
9349 Returns 1 on success. */
9352 try_one_overload (tree tparms,
9357 unification_kind_t strict,
9365 /* [temp.deduct.type] A template-argument can be deduced from a pointer
9366 to function or pointer to member function argument if the set of
9367 overloaded functions does not contain function templates and at most
9368 one of a set of overloaded functions provides a unique match.
9370 So if this is a template, just return success. */
9372 if (uses_template_parms (arg))
9375 if (TREE_CODE (arg) == METHOD_TYPE)
9376 arg = build_ptrmemfunc_type (build_pointer_type (arg));
9378 arg = build_pointer_type (arg);
9380 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9382 /* We don't copy orig_targs for this because if we have already deduced
9383 some template args from previous args, unify would complain when we
9384 try to deduce a template parameter for the same argument, even though
9385 there isn't really a conflict. */
9386 nargs = TREE_VEC_LENGTH (targs);
9387 tempargs = make_tree_vec (nargs);
9389 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
9392 /* First make sure we didn't deduce anything that conflicts with
9393 explicitly specified args. */
9394 for (i = nargs; i--; )
9396 tree elt = TREE_VEC_ELT (tempargs, i);
9397 tree oldelt = TREE_VEC_ELT (orig_targs, i);
9399 if (elt == NULL_TREE)
9401 else if (uses_template_parms (elt))
9403 /* Since we're unifying against ourselves, we will fill in template
9404 args used in the function parm list with our own template parms.
9406 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
9409 else if (oldelt && ! template_args_equal (oldelt, elt))
9413 for (i = nargs; i--; )
9415 tree elt = TREE_VEC_ELT (tempargs, i);
9418 TREE_VEC_ELT (targs, i) = elt;
9424 /* Verify that nondeduce template argument agrees with the type
9425 obtained from argument deduction. Return nonzero if the
9430 struct A { typedef int X; };
9431 template <class T, class U> struct C {};
9432 template <class T> struct C<T, typename T::X> {};
9434 Then with the instantiation `C<A, int>', we can deduce that
9435 `T' is `A' but unify () does not check whether `typename T::X'
9436 is `int'. This function ensure that they agree.
9438 TARGS, PARMS are the same as the arguments of unify.
9439 ARGS contains template arguments from all levels. */
9442 verify_class_unification (tree targs, tree parms, tree args)
9444 parms = tsubst (parms, add_outermost_template_args (args, targs),
9445 tf_none, NULL_TREE);
9446 if (parms == error_mark_node)
9449 return !comp_template_args (parms, INNERMOST_TEMPLATE_ARGS (args));
9452 /* PARM is a template class (perhaps with unbound template
9453 parameters). ARG is a fully instantiated type. If ARG can be
9454 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
9455 TARGS are as for unify. */
9458 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
9462 if (!CLASSTYPE_TEMPLATE_INFO (arg)
9463 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
9464 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
9467 /* We need to make a new template argument vector for the call to
9468 unify. If we used TARGS, we'd clutter it up with the result of
9469 the attempted unification, even if this class didn't work out.
9470 We also don't want to commit ourselves to all the unifications
9471 we've already done, since unification is supposed to be done on
9472 an argument-by-argument basis. In other words, consider the
9473 following pathological case:
9475 template <int I, int J, int K>
9478 template <int I, int J>
9479 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
9481 template <int I, int J, int K>
9482 void f(S<I, J, K>, S<I, I, I>);
9491 Now, by the time we consider the unification involving `s2', we
9492 already know that we must have `f<0, 0, 0>'. But, even though
9493 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
9494 because there are two ways to unify base classes of S<0, 1, 2>
9495 with S<I, I, I>. If we kept the already deduced knowledge, we
9496 would reject the possibility I=1. */
9497 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
9499 /* If unification failed, we're done. */
9500 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
9501 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
9507 /* Subroutine of get_template_base. RVAL, if non-NULL, is a base we
9508 have already discovered to be satisfactory. ARG_BINFO is the binfo
9509 for the base class of ARG that we are currently examining. */
9512 get_template_base_recursive (tree tparms,
9521 tree arg = BINFO_TYPE (arg_binfo);
9523 if (!(flags & GTB_IGNORE_TYPE))
9525 tree r = try_class_unification (tparms, targs,
9528 /* If there is more than one satisfactory baseclass, then:
9532 If they yield more than one possible deduced A, the type
9536 if (r && rval && !same_type_p (r, rval))
9537 return error_mark_node;
9542 binfos = BINFO_BASETYPES (arg_binfo);
9543 n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
9545 /* Process base types. */
9546 for (i = 0; i < n_baselinks; i++)
9548 tree base_binfo = TREE_VEC_ELT (binfos, i);
9551 /* Skip this base, if we've already seen it. */
9552 if (BINFO_MARKED (base_binfo))
9556 (flags & GTB_VIA_VIRTUAL) || TREE_VIA_VIRTUAL (base_binfo);
9558 /* When searching for a non-virtual, we cannot mark virtually
9561 BINFO_MARKED (base_binfo) = 1;
9563 rval = get_template_base_recursive (tparms, targs,
9567 GTB_VIA_VIRTUAL * this_virtual);
9569 /* If we discovered more than one matching base class, we can
9571 if (rval == error_mark_node)
9572 return error_mark_node;
9578 /* Given a template type PARM and a class type ARG, find the unique
9579 base type in ARG that is an instance of PARM. We do not examine
9580 ARG itself; only its base-classes. If there is no appropriate base
9581 class, return NULL_TREE. If there is more than one, return
9582 error_mark_node. PARM may be the type of a partial specialization,
9583 as well as a plain template type. Used by unify. */
9586 get_template_base (tree tparms, tree targs, tree parm, tree arg)
9591 my_friendly_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)), 92);
9593 arg_binfo = TYPE_BINFO (complete_type (arg));
9594 rval = get_template_base_recursive (tparms, targs,
9599 /* Since get_template_base_recursive marks the bases classes, we
9600 must unmark them here. */
9601 dfs_walk (arg_binfo, dfs_unmark, markedp, 0);
9606 /* Returns the level of DECL, which declares a template parameter. */
9609 template_decl_level (tree decl)
9611 switch (TREE_CODE (decl))
9615 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
9618 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
9626 /* Decide whether ARG can be unified with PARM, considering only the
9627 cv-qualifiers of each type, given STRICT as documented for unify.
9628 Returns nonzero iff the unification is OK on that basis. */
9631 check_cv_quals_for_unify (int strict, tree arg, tree parm)
9633 int arg_quals = cp_type_quals (arg);
9634 int parm_quals = cp_type_quals (parm);
9636 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
9637 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
9639 /* Although a CVR qualifier is ignored when being applied to a
9640 substituted template parameter ([8.3.2]/1 for example), that
9641 does not apply during deduction [14.8.2.4]/1, (even though
9642 that is not explicitly mentioned, [14.8.2.4]/9 indicates
9643 this). Except when we're allowing additional CV qualifiers
9644 at the outer level [14.8.2.1]/3,1st bullet. */
9645 if ((TREE_CODE (arg) == REFERENCE_TYPE
9646 || TREE_CODE (arg) == FUNCTION_TYPE
9647 || TREE_CODE (arg) == METHOD_TYPE)
9648 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
9651 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
9652 && (parm_quals & TYPE_QUAL_RESTRICT))
9656 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
9657 && (arg_quals & parm_quals) != parm_quals)
9660 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
9661 && (parm_quals & arg_quals) != arg_quals)
9667 /* Takes parameters as for type_unification. Returns 0 if the
9668 type deduction succeeds, 1 otherwise. The parameter STRICT is a
9669 bitwise or of the following flags:
9672 Require an exact match between PARM and ARG.
9673 UNIFY_ALLOW_MORE_CV_QUAL:
9674 Allow the deduced ARG to be more cv-qualified (by qualification
9675 conversion) than ARG.
9676 UNIFY_ALLOW_LESS_CV_QUAL:
9677 Allow the deduced ARG to be less cv-qualified than ARG.
9678 UNIFY_ALLOW_DERIVED:
9679 Allow the deduced ARG to be a template base class of ARG,
9680 or a pointer to a template base class of the type pointed to by
9682 UNIFY_ALLOW_INTEGER:
9683 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
9684 case for more information.
9685 UNIFY_ALLOW_OUTER_LEVEL:
9686 This is the outermost level of a deduction. Used to determine validity
9687 of qualification conversions. A valid qualification conversion must
9688 have const qualified pointers leading up to the inner type which
9689 requires additional CV quals, except at the outer level, where const
9690 is not required [conv.qual]. It would be normal to set this flag in
9691 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
9692 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
9693 This is the outermost level of a deduction, and PARM can be more CV
9694 qualified at this point.
9695 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
9696 This is the outermost level of a deduction, and PARM can be less CV
9697 qualified at this point.
9698 UNIFY_ALLOW_MAX_CORRECTION:
9699 This is an INTEGER_TYPE's maximum value. Used if the range may
9700 have been derived from a size specification, such as an array size.
9701 If the size was given by a nontype template parameter N, the maximum
9702 value will have the form N-1. The flag says that we can (and indeed
9703 must) unify N with (ARG + 1), an exception to the normal rules on
9707 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
9712 int strict_in = strict;
9714 /* I don't think this will do the right thing with respect to types.
9715 But the only case I've seen it in so far has been array bounds, where
9716 signedness is the only information lost, and I think that will be
9718 while (TREE_CODE (parm) == NOP_EXPR)
9719 parm = TREE_OPERAND (parm, 0);
9721 if (arg == error_mark_node)
9723 if (arg == unknown_type_node)
9724 /* We can't deduce anything from this, but we might get all the
9725 template args from other function args. */
9728 /* If PARM uses template parameters, then we can't bail out here,
9729 even if ARG == PARM, since we won't record unifications for the
9730 template parameters. We might need them if we're trying to
9731 figure out which of two things is more specialized. */
9732 if (arg == parm && !uses_template_parms (parm))
9735 /* Immediately reject some pairs that won't unify because of
9736 cv-qualification mismatches. */
9737 if (TREE_CODE (arg) == TREE_CODE (parm)
9739 /* It is the elements of the array which hold the cv quals of an array
9740 type, and the elements might be template type parms. We'll check
9742 && TREE_CODE (arg) != ARRAY_TYPE
9743 /* We check the cv-qualifiers when unifying with template type
9744 parameters below. We want to allow ARG `const T' to unify with
9745 PARM `T' for example, when computing which of two templates
9746 is more specialized, for example. */
9747 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
9748 && !check_cv_quals_for_unify (strict_in, arg, parm))
9751 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
9752 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
9753 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
9754 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
9755 strict &= ~UNIFY_ALLOW_DERIVED;
9756 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9757 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
9758 strict &= ~UNIFY_ALLOW_MAX_CORRECTION;
9760 switch (TREE_CODE (parm))
9764 case UNBOUND_CLASS_TEMPLATE:
9765 /* In a type which contains a nested-name-specifier, template
9766 argument values cannot be deduced for template parameters used
9767 within the nested-name-specifier. */
9770 case TEMPLATE_TYPE_PARM:
9771 case TEMPLATE_TEMPLATE_PARM:
9772 case BOUND_TEMPLATE_TEMPLATE_PARM:
9773 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
9775 if (TEMPLATE_TYPE_LEVEL (parm)
9776 != template_decl_level (tparm))
9777 /* The PARM is not one we're trying to unify. Just check
9778 to see if it matches ARG. */
9779 return (TREE_CODE (arg) == TREE_CODE (parm)
9780 && same_type_p (parm, arg)) ? 0 : 1;
9781 idx = TEMPLATE_TYPE_IDX (parm);
9782 targ = TREE_VEC_ELT (targs, idx);
9783 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
9785 /* Check for mixed types and values. */
9786 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
9787 && TREE_CODE (tparm) != TYPE_DECL)
9788 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
9789 && TREE_CODE (tparm) != TEMPLATE_DECL))
9792 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
9794 /* ARG must be constructed from a template class or a template
9795 template parameter. */
9796 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
9797 && (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg)))
9801 tree parmtmpl = TYPE_TI_TEMPLATE (parm);
9802 tree parmvec = TYPE_TI_ARGS (parm);
9803 tree argvec = TYPE_TI_ARGS (arg);
9805 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
9808 /* The parameter and argument roles have to be switched here
9809 in order to handle default arguments properly. For example,
9810 template<template <class> class TT> void f(TT<int>)
9811 should be able to accept vector<int> which comes from
9812 template <class T, class Allocator = allocator>
9815 if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1)
9819 /* Deduce arguments T, i from TT<T> or TT<i>.
9820 We check each element of PARMVEC and ARGVEC individually
9821 rather than the whole TREE_VEC since they can have
9822 different number of elements. */
9824 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
9826 tree t = TREE_VEC_ELT (parmvec, i);
9828 if (unify (tparms, targs, t,
9829 TREE_VEC_ELT (argvec, i),
9834 arg = TYPE_TI_TEMPLATE (arg);
9836 /* Fall through to deduce template name. */
9839 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
9840 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
9842 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
9844 /* Simple cases: Value already set, does match or doesn't. */
9845 if (targ != NULL_TREE && template_args_equal (targ, arg))
9852 /* If PARM is `const T' and ARG is only `int', we don't have
9853 a match unless we are allowing additional qualification.
9854 If ARG is `const int' and PARM is just `T' that's OK;
9855 that binds `const int' to `T'. */
9856 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
9860 /* Consider the case where ARG is `const volatile int' and
9861 PARM is `const T'. Then, T should be `volatile int'. */
9862 arg = cp_build_qualified_type_real
9863 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
9864 if (arg == error_mark_node)
9867 /* Simple cases: Value already set, does match or doesn't. */
9868 if (targ != NULL_TREE && same_type_p (targ, arg))
9873 /* Make sure that ARG is not a variable-sized array. (Note
9874 that were talking about variable-sized arrays (like
9875 `int[n]'), rather than arrays of unknown size (like
9876 `int[]').) We'll get very confused by such a type since
9877 the bound of the array will not be computable in an
9878 instantiation. Besides, such types are not allowed in
9879 ISO C++, so we can do as we please here. */
9880 if (variably_modified_type_p (arg))
9884 TREE_VEC_ELT (targs, idx) = arg;
9887 case TEMPLATE_PARM_INDEX:
9888 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
9890 if (TEMPLATE_PARM_LEVEL (parm)
9891 != template_decl_level (tparm))
9892 /* The PARM is not one we're trying to unify. Just check
9893 to see if it matches ARG. */
9894 return !(TREE_CODE (arg) == TREE_CODE (parm)
9895 && cp_tree_equal (parm, arg));
9897 idx = TEMPLATE_PARM_IDX (parm);
9898 targ = TREE_VEC_ELT (targs, idx);
9901 return !cp_tree_equal (targ, arg);
9903 /* [temp.deduct.type] If, in the declaration of a function template
9904 with a non-type template-parameter, the non-type
9905 template-parameter is used in an expression in the function
9906 parameter-list and, if the corresponding template-argument is
9907 deduced, the template-argument type shall match the type of the
9908 template-parameter exactly, except that a template-argument
9909 deduced from an array bound may be of any integral type.
9910 The non-type parameter might use already deduced type parameters. */
9911 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
9912 if (!TREE_TYPE (arg))
9913 /* Template-parameter dependent expression. Just accept it for now.
9914 It will later be processed in convert_template_argument. */
9916 else if (same_type_p (TREE_TYPE (arg), tparm))
9918 else if ((strict & UNIFY_ALLOW_INTEGER)
9919 && (TREE_CODE (tparm) == INTEGER_TYPE
9920 || TREE_CODE (tparm) == BOOLEAN_TYPE))
9921 /* Convert the ARG to the type of PARM; the deduced non-type
9922 template argument must exactly match the types of the
9923 corresponding parameter. */
9924 arg = fold (build_nop (TREE_TYPE (parm), arg));
9925 else if (uses_template_parms (tparm))
9926 /* We haven't deduced the type of this parameter yet. Try again
9932 TREE_VEC_ELT (targs, idx) = arg;
9937 /* A pointer-to-member constant can be unified only with
9938 another constant. */
9939 if (TREE_CODE (arg) != PTRMEM_CST)
9942 /* Just unify the class member. It would be useless (and possibly
9943 wrong, depending on the strict flags) to unify also
9944 PTRMEM_CST_CLASS, because we want to be sure that both parm and
9945 arg refer to the same variable, even if through different
9946 classes. For instance:
9948 struct A { int x; };
9951 Unification of &A::x and &B::x must succeed. */
9952 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
9953 PTRMEM_CST_MEMBER (arg), strict);
9958 if (TREE_CODE (arg) != POINTER_TYPE)
9961 /* [temp.deduct.call]
9963 A can be another pointer or pointer to member type that can
9964 be converted to the deduced A via a qualification
9965 conversion (_conv.qual_).
9967 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
9968 This will allow for additional cv-qualification of the
9969 pointed-to types if appropriate. */
9971 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
9972 /* The derived-to-base conversion only persists through one
9973 level of pointers. */
9974 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
9976 return unify (tparms, targs, TREE_TYPE (parm),
9977 TREE_TYPE (arg), strict);
9980 case REFERENCE_TYPE:
9981 if (TREE_CODE (arg) != REFERENCE_TYPE)
9983 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
9984 strict & UNIFY_ALLOW_MORE_CV_QUAL);
9987 if (TREE_CODE (arg) != ARRAY_TYPE)
9989 if ((TYPE_DOMAIN (parm) == NULL_TREE)
9990 != (TYPE_DOMAIN (arg) == NULL_TREE))
9992 if (TYPE_DOMAIN (parm) != NULL_TREE
9993 && unify (tparms, targs, TYPE_DOMAIN (parm),
9994 TYPE_DOMAIN (arg), UNIFY_ALLOW_NONE) != 0)
9996 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
9997 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10004 case ENUMERAL_TYPE:
10006 if (TREE_CODE (arg) != TREE_CODE (parm))
10009 if (TREE_CODE (parm) == INTEGER_TYPE
10010 && TREE_CODE (TYPE_MAX_VALUE (parm)) != INTEGER_CST)
10012 if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg)
10013 && unify (tparms, targs, TYPE_MIN_VALUE (parm),
10014 TYPE_MIN_VALUE (arg), UNIFY_ALLOW_INTEGER))
10016 if (TYPE_MAX_VALUE (parm) && TYPE_MAX_VALUE (arg)
10017 && unify (tparms, targs, TYPE_MAX_VALUE (parm),
10018 TYPE_MAX_VALUE (arg),
10019 UNIFY_ALLOW_INTEGER | UNIFY_ALLOW_MAX_CORRECTION))
10022 /* We have already checked cv-qualification at the top of the
10024 else if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10027 /* As far as unification is concerned, this wins. Later checks
10028 will invalidate it if necessary. */
10031 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10032 /* Type INTEGER_CST can come from ordinary constant template args. */
10034 while (TREE_CODE (arg) == NOP_EXPR)
10035 arg = TREE_OPERAND (arg, 0);
10037 if (TREE_CODE (arg) != INTEGER_CST)
10039 return !tree_int_cst_equal (parm, arg);
10044 if (TREE_CODE (arg) != TREE_VEC)
10046 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10048 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10049 if (unify (tparms, targs,
10050 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10058 if (TREE_CODE (arg) != TREE_CODE (parm))
10061 if (TYPE_PTRMEMFUNC_P (parm))
10063 if (!TYPE_PTRMEMFUNC_P (arg))
10066 return unify (tparms, targs,
10067 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10068 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10072 if (CLASSTYPE_TEMPLATE_INFO (parm))
10074 tree t = NULL_TREE;
10076 if (strict_in & UNIFY_ALLOW_DERIVED)
10078 /* First, we try to unify the PARM and ARG directly. */
10079 t = try_class_unification (tparms, targs,
10084 /* Fallback to the special case allowed in
10085 [temp.deduct.call]:
10087 If P is a class, and P has the form
10088 template-id, then A can be a derived class of
10089 the deduced A. Likewise, if P is a pointer to
10090 a class of the form template-id, A can be a
10091 pointer to a derived class pointed to by the
10093 t = get_template_base (tparms, targs,
10096 if (! t || t == error_mark_node)
10100 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10101 && (CLASSTYPE_TI_TEMPLATE (parm)
10102 == CLASSTYPE_TI_TEMPLATE (arg)))
10103 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10104 Then, we should unify `int' and `U'. */
10107 /* There's no chance of unification succeeding. */
10110 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10111 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10113 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10118 case FUNCTION_TYPE:
10119 if (TREE_CODE (arg) != TREE_CODE (parm))
10122 if (unify (tparms, targs, TREE_TYPE (parm),
10123 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10125 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10126 TYPE_ARG_TYPES (arg), 1,
10127 DEDUCE_EXACT, 0, -1);
10130 if (TREE_CODE (arg) != OFFSET_TYPE)
10132 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10133 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10135 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10139 if (DECL_TEMPLATE_PARM_P (parm))
10140 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10141 if (arg != decl_constant_value (parm))
10146 case TEMPLATE_DECL:
10147 /* Matched cases are handled by the ARG == PARM test above. */
10151 if (tree_int_cst_equal (TREE_OPERAND (parm, 1), integer_one_node)
10152 && (strict_in & UNIFY_ALLOW_MAX_CORRECTION))
10154 /* We handle this case specially, since it comes up with
10155 arrays. In particular, something like:
10157 template <int N> void f(int (&x)[N]);
10159 Here, we are trying to unify the range type, which
10160 looks like [0 ... (N - 1)]. */
10162 t1 = TREE_OPERAND (parm, 0);
10163 t2 = TREE_OPERAND (parm, 1);
10165 t = fold (build (PLUS_EXPR, integer_type_node, arg, t2));
10167 return unify (tparms, targs, t1, t, strict);
10169 /* Else fall through. */
10172 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (parm))))
10175 /* We're looking at an expression. This can happen with
10179 void foo(S<I>, S<I + 2>);
10181 This is a "nondeduced context":
10185 The nondeduced contexts are:
10187 --A type that is a template-id in which one or more of
10188 the template-arguments is an expression that references
10189 a template-parameter.
10191 In these cases, we assume deduction succeeded, but don't
10192 actually infer any unifications. */
10194 if (!uses_template_parms (parm)
10195 && !template_args_equal (parm, arg))
10200 sorry ("use of `%s' in template type unification",
10201 tree_code_name [(int) TREE_CODE (parm)]);
10206 /* Called if RESULT is explicitly instantiated, or is a member of an
10207 explicitly instantiated class, or if using -frepo and the
10208 instantiation of RESULT has been assigned to this file. */
10211 mark_decl_instantiated (tree result, int extern_p)
10213 /* We used to set this unconditionally; we moved that to
10214 do_decl_instantiation so it wouldn't get set on members of
10215 explicit class template instantiations. But we still need to set
10216 it here for the 'extern template' case in order to suppress
10217 implicit instantiations. */
10219 SET_DECL_EXPLICIT_INSTANTIATION (result);
10221 /* If this entity has already been written out, it's too late to
10222 make any modifications. */
10223 if (TREE_ASM_WRITTEN (result))
10226 if (TREE_CODE (result) != FUNCTION_DECL)
10227 /* The TREE_PUBLIC flag for function declarations will have been
10228 set correctly by tsubst. */
10229 TREE_PUBLIC (result) = 1;
10231 /* This might have been set by an earlier implicit instantiation. */
10232 DECL_COMDAT (result) = 0;
10236 DECL_INTERFACE_KNOWN (result) = 1;
10237 DECL_NOT_REALLY_EXTERN (result) = 1;
10239 /* Always make artificials weak. */
10240 if (DECL_ARTIFICIAL (result) && flag_weak)
10241 comdat_linkage (result);
10242 /* For WIN32 we also want to put explicit instantiations in
10243 linkonce sections. */
10244 else if (TREE_PUBLIC (result))
10245 maybe_make_one_only (result);
10248 if (TREE_CODE (result) == FUNCTION_DECL)
10252 /* Given two function templates PAT1 and PAT2, return:
10254 DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER.
10256 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
10257 -1 if PAT2 is more specialized than PAT1.
10258 0 if neither is more specialized.
10260 LEN is passed through to fn_type_unification. */
10263 more_specialized (tree pat1, tree pat2, int deduce, int len)
10268 /* If template argument deduction succeeds, we substitute the
10269 resulting arguments into non-deduced contexts. While doing that,
10270 we must be aware that we may encounter dependent types. */
10271 ++processing_template_decl;
10272 targs = get_bindings_real (pat1, DECL_TEMPLATE_RESULT (pat2),
10273 NULL_TREE, 0, deduce, len);
10277 targs = get_bindings_real (pat2, DECL_TEMPLATE_RESULT (pat1),
10278 NULL_TREE, 0, deduce, len);
10281 --processing_template_decl;
10286 /* Given two class template specialization list nodes PAT1 and PAT2, return:
10288 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
10289 -1 if PAT2 is more specialized than PAT1.
10290 0 if neither is more specialized.
10292 FULL_ARGS is the full set of template arguments that triggers this
10293 partial ordering. */
10296 more_specialized_class (tree pat1, tree pat2, tree full_args)
10301 /* Just like what happens for functions, if we are ordering between
10302 different class template specializations, we may encounter dependent
10303 types in the arguments, and we need our dependency check functions
10304 to behave correctly. */
10305 ++processing_template_decl;
10306 targs = get_class_bindings (TREE_VALUE (pat1), TREE_PURPOSE (pat1),
10307 add_outermost_template_args (full_args, TREE_PURPOSE (pat2)));
10311 targs = get_class_bindings (TREE_VALUE (pat2), TREE_PURPOSE (pat2),
10312 add_outermost_template_args (full_args, TREE_PURPOSE (pat1)));
10315 --processing_template_decl;
10320 /* Return the template arguments that will produce the function signature
10321 DECL from the function template FN, with the explicit template
10322 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
10323 also match. Return NULL_TREE if no satisfactory arguments could be
10324 found. DEDUCE and LEN are passed through to fn_type_unification. */
10327 get_bindings_real (tree fn,
10329 tree explicit_args,
10334 int ntparms = DECL_NTPARMS (fn);
10335 tree targs = make_tree_vec (ntparms);
10337 tree decl_arg_types;
10340 /* Substitute the explicit template arguments into the type of DECL.
10341 The call to fn_type_unification will handle substitution into the
10343 decl_type = TREE_TYPE (decl);
10344 if (explicit_args && uses_template_parms (decl_type))
10347 tree converted_args;
10349 if (DECL_TEMPLATE_INFO (decl))
10350 tmpl = DECL_TI_TEMPLATE (decl);
10352 /* We can get here for some invalid specializations. */
10356 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
10357 explicit_args, NULL_TREE,
10358 tf_none, /*require_all_arguments=*/0));
10359 if (converted_args == error_mark_node)
10362 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
10363 if (decl_type == error_mark_node)
10367 decl_arg_types = TYPE_ARG_TYPES (decl_type);
10368 /* Never do unification on the 'this' parameter. */
10369 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
10370 decl_arg_types = TREE_CHAIN (decl_arg_types);
10372 i = fn_type_unification (fn, explicit_args, targs,
10374 (check_rettype || DECL_CONV_FN_P (fn)
10375 ? TREE_TYPE (decl_type) : NULL_TREE),
10384 /* For most uses, we want to check the return type. */
10387 get_bindings (tree fn, tree decl, tree explicit_args)
10389 return get_bindings_real (fn, decl, explicit_args, 1, DEDUCE_EXACT, -1);
10392 /* But for resolve_overloaded_unification, we only care about the parameter
10396 get_bindings_overload (tree fn, tree decl, tree explicit_args)
10398 return get_bindings_real (fn, decl, explicit_args, 0, DEDUCE_EXACT, -1);
10401 /* Return the innermost template arguments that, when applied to a
10402 template specialization whose innermost template parameters are
10403 TPARMS, and whose specialization arguments are PARMS, yield the
10406 For example, suppose we have:
10408 template <class T, class U> struct S {};
10409 template <class T> struct S<T*, int> {};
10411 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
10412 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
10413 int}. The resulting vector will be {double}, indicating that `T'
10414 is bound to `double'. */
10417 get_class_bindings (tree tparms, tree parms, tree args)
10419 int i, ntparms = TREE_VEC_LENGTH (tparms);
10420 tree vec = make_tree_vec (ntparms);
10422 if (unify (tparms, vec, parms, INNERMOST_TEMPLATE_ARGS (args),
10426 for (i = 0; i < ntparms; ++i)
10427 if (! TREE_VEC_ELT (vec, i))
10430 if (verify_class_unification (vec, parms, args))
10436 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
10437 Pick the most specialized template, and return the corresponding
10438 instantiation, or if there is no corresponding instantiation, the
10439 template itself. If there is no most specialized template,
10440 error_mark_node is returned. If there are no templates at all,
10441 NULL_TREE is returned. */
10444 most_specialized_instantiation (tree instantiations)
10449 if (!instantiations)
10452 champ = instantiations;
10453 for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn))
10455 fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn),
10463 fn = TREE_CHAIN (fn);
10465 return error_mark_node;
10471 for (fn = instantiations; fn && fn != champ; fn = TREE_CHAIN (fn))
10473 fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn),
10476 return error_mark_node;
10479 return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ);
10482 /* Return the most specialized of the list of templates in FNS that can
10483 produce an instantiation matching DECL, given the explicit template
10484 arguments EXPLICIT_ARGS. */
10487 most_specialized (tree fns, tree decl, tree explicit_args)
10489 tree candidates = NULL_TREE;
10492 for (fn = fns; fn; fn = TREE_CHAIN (fn))
10494 tree candidate = TREE_VALUE (fn);
10496 args = get_bindings (candidate, decl, explicit_args);
10498 candidates = tree_cons (NULL_TREE, candidate, candidates);
10501 return most_specialized_instantiation (candidates);
10504 /* If DECL is a specialization of some template, return the most
10505 general such template. Otherwise, returns NULL_TREE.
10507 For example, given:
10509 template <class T> struct S { template <class U> void f(U); };
10511 if TMPL is `template <class U> void S<int>::f(U)' this will return
10512 the full template. This function will not trace past partial
10513 specializations, however. For example, given in addition:
10515 template <class T> struct S<T*> { template <class U> void f(U); };
10517 if TMPL is `template <class U> void S<int*>::f(U)' this will return
10518 `template <class T> template <class U> S<T*>::f(U)'. */
10521 most_general_template (tree decl)
10523 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
10524 an immediate specialization. */
10525 if (TREE_CODE (decl) == FUNCTION_DECL)
10527 if (DECL_TEMPLATE_INFO (decl)) {
10528 decl = DECL_TI_TEMPLATE (decl);
10530 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
10531 template friend. */
10532 if (TREE_CODE (decl) != TEMPLATE_DECL)
10538 /* Look for more and more general templates. */
10539 while (DECL_TEMPLATE_INFO (decl))
10541 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
10542 (See cp-tree.h for details.) */
10543 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
10546 if (CLASS_TYPE_P (TREE_TYPE (decl))
10547 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
10550 /* Stop if we run into an explicitly specialized class template. */
10551 if (!DECL_NAMESPACE_SCOPE_P (decl)
10552 && DECL_CONTEXT (decl)
10553 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
10556 decl = DECL_TI_TEMPLATE (decl);
10562 /* Return the most specialized of the class template specializations
10563 of TMPL which can produce an instantiation matching ARGS, or
10564 error_mark_node if the choice is ambiguous. */
10567 most_specialized_class (tree tmpl, tree args)
10569 tree list = NULL_TREE;
10574 tmpl = most_general_template (tmpl);
10575 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
10578 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args);
10581 list = tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list);
10582 TREE_TYPE (list) = TREE_TYPE (t);
10591 t = TREE_CHAIN (t);
10592 for (; t; t = TREE_CHAIN (t))
10594 fate = more_specialized_class (champ, t, args);
10601 t = TREE_CHAIN (t);
10603 return error_mark_node;
10609 for (t = list; t && t != champ; t = TREE_CHAIN (t))
10611 fate = more_specialized_class (champ, t, args);
10613 return error_mark_node;
10619 /* Explicitly instantiate DECL. */
10622 do_decl_instantiation (tree decl, tree storage)
10624 tree result = NULL_TREE;
10628 /* An error occurred, for which grokdeclarator has already issued
10629 an appropriate message. */
10631 else if (! DECL_LANG_SPECIFIC (decl))
10633 error ("explicit instantiation of non-template `%#D'", decl);
10636 else if (TREE_CODE (decl) == VAR_DECL)
10638 /* There is an asymmetry here in the way VAR_DECLs and
10639 FUNCTION_DECLs are handled by grokdeclarator. In the case of
10640 the latter, the DECL we get back will be marked as a
10641 template instantiation, and the appropriate
10642 DECL_TEMPLATE_INFO will be set up. This does not happen for
10643 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
10644 should handle VAR_DECLs as it currently handles
10646 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
10647 if (!result || TREE_CODE (result) != VAR_DECL)
10649 error ("no matching template for `%D' found", decl);
10653 else if (TREE_CODE (decl) != FUNCTION_DECL)
10655 error ("explicit instantiation of `%#D'", decl);
10661 /* Check for various error cases. Note that if the explicit
10662 instantiation is valid the RESULT will currently be marked as an
10663 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
10664 until we get here. */
10666 if (DECL_TEMPLATE_SPECIALIZATION (result))
10668 /* DR 259 [temp.spec].
10670 Both an explicit instantiation and a declaration of an explicit
10671 specialization shall not appear in a program unless the explicit
10672 instantiation follows a declaration of the explicit specialization.
10674 For a given set of template parameters, if an explicit
10675 instantiation of a template appears after a declaration of an
10676 explicit specialization for that template, the explicit
10677 instantiation has no effect. */
10680 else if (DECL_EXPLICIT_INSTANTIATION (result))
10684 No program shall explicitly instantiate any template more
10687 We check DECL_INTERFACE_KNOWN so as not to complain when the first
10688 instantiation was `extern' and the second is not, and EXTERN_P for
10689 the opposite case. If -frepo, chances are we already got marked
10690 as an explicit instantiation because of the repo file. */
10691 if (DECL_INTERFACE_KNOWN (result) && !extern_p && !flag_use_repository)
10692 pedwarn ("duplicate explicit instantiation of `%#D'", result);
10694 /* If we've already instantiated the template, just return now. */
10695 if (DECL_INTERFACE_KNOWN (result))
10698 else if (!DECL_IMPLICIT_INSTANTIATION (result))
10700 error ("no matching template for `%D' found", result);
10703 else if (!DECL_TEMPLATE_INFO (result))
10705 pedwarn ("explicit instantiation of non-template `%#D'", result);
10709 if (storage == NULL_TREE)
10711 else if (storage == ridpointers[(int) RID_EXTERN])
10713 if (pedantic && !in_system_header)
10714 pedwarn ("ISO C++ forbids the use of `extern' on explicit instantiations");
10718 error ("storage class `%D' applied to template instantiation",
10721 SET_DECL_EXPLICIT_INSTANTIATION (result);
10722 mark_decl_instantiated (result, extern_p);
10723 repo_template_instantiated (result, extern_p);
10725 instantiate_decl (result, /*defer_ok=*/1);
10729 mark_class_instantiated (tree t, int extern_p)
10731 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
10732 SET_CLASSTYPE_INTERFACE_KNOWN (t);
10733 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
10734 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
10737 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
10738 rest_of_type_compilation (t, 1);
10742 /* Called from do_type_instantiation through binding_table_foreach to
10743 do recursive instantiation for the type bound in ENTRY. */
10745 bt_instantiate_type_proc (binding_entry entry, void *data)
10747 tree storage = *(tree *) data;
10749 if (IS_AGGR_TYPE (entry->type)
10750 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
10751 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
10754 /* Perform an explicit instantiation of template class T. STORAGE, if
10755 non-null, is the RID for extern, inline or static. COMPLAIN is
10756 nonzero if this is called from the parser, zero if called recursively,
10757 since the standard is unclear (as detailed below). */
10760 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
10766 if (TREE_CODE (t) == TYPE_DECL)
10769 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
10771 error ("explicit instantiation of non-template type `%T'", t);
10777 if (!COMPLETE_TYPE_P (t))
10779 if (complain & tf_error)
10780 error ("explicit instantiation of `%#T' before definition of template",
10785 if (storage != NULL_TREE)
10787 if (pedantic && !in_system_header)
10788 pedwarn("ISO C++ forbids the use of `%s' on explicit instantiations",
10789 IDENTIFIER_POINTER (storage));
10791 if (storage == ridpointers[(int) RID_INLINE])
10793 else if (storage == ridpointers[(int) RID_EXTERN])
10795 else if (storage == ridpointers[(int) RID_STATIC])
10799 error ("storage class `%D' applied to template instantiation",
10805 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10807 /* DR 259 [temp.spec].
10809 Both an explicit instantiation and a declaration of an explicit
10810 specialization shall not appear in a program unless the explicit
10811 instantiation follows a declaration of the explicit specialization.
10813 For a given set of template parameters, if an explicit
10814 instantiation of a template appears after a declaration of an
10815 explicit specialization for that template, the explicit
10816 instantiation has no effect. */
10819 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
10823 No program shall explicitly instantiate any template more
10826 If CLASSTYPE_INTERFACE_ONLY, then the first explicit instantiation
10827 was `extern'. If EXTERN_P then the second is. If -frepo, chances
10828 are we already got marked as an explicit instantiation because of the
10829 repo file. All these cases are OK. */
10830 if (!CLASSTYPE_INTERFACE_ONLY (t) && !extern_p && !flag_use_repository
10831 && (complain & tf_error))
10832 pedwarn ("duplicate explicit instantiation of `%#T'", t);
10834 /* If we've already instantiated the template, just return now. */
10835 if (!CLASSTYPE_INTERFACE_ONLY (t))
10839 mark_class_instantiated (t, extern_p);
10840 repo_template_instantiated (t, extern_p);
10848 /* In contrast to implicit instantiation, where only the
10849 declarations, and not the definitions, of members are
10850 instantiated, we have here:
10854 The explicit instantiation of a class template specialization
10855 implies the instantiation of all of its members not
10856 previously explicitly specialized in the translation unit
10857 containing the explicit instantiation.
10859 Of course, we can't instantiate member template classes, since
10860 we don't have any arguments for them. Note that the standard
10861 is unclear on whether the instantiation of the members are
10862 *explicit* instantiations or not. We choose to be generous,
10863 and not set DECL_EXPLICIT_INSTANTIATION. Therefore, we allow
10864 the explicit instantiation of a class where some of the members
10865 have no definition in the current translation unit. */
10868 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
10869 if (TREE_CODE (tmp) == FUNCTION_DECL
10870 && DECL_TEMPLATE_INSTANTIATION (tmp))
10872 mark_decl_instantiated (tmp, extern_p);
10873 repo_template_instantiated (tmp, extern_p);
10875 instantiate_decl (tmp, /*defer_ok=*/1);
10878 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
10879 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
10881 mark_decl_instantiated (tmp, extern_p);
10882 repo_template_instantiated (tmp, extern_p);
10884 instantiate_decl (tmp, /*defer_ok=*/1);
10887 if (CLASSTYPE_NESTED_UTDS (t))
10888 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
10889 bt_instantiate_type_proc, &storage);
10893 /* Given a function DECL, which is a specialization of TMPL, modify
10894 DECL to be a re-instantiation of TMPL with the same template
10895 arguments. TMPL should be the template into which tsubst'ing
10896 should occur for DECL, not the most general template.
10898 One reason for doing this is a scenario like this:
10901 void f(const T&, int i);
10903 void g() { f(3, 7); }
10906 void f(const T& t, const int i) { }
10908 Note that when the template is first instantiated, with
10909 instantiate_template, the resulting DECL will have no name for the
10910 first parameter, and the wrong type for the second. So, when we go
10911 to instantiate the DECL, we regenerate it. */
10914 regenerate_decl_from_template (tree decl, tree tmpl)
10916 /* The most general version of TMPL. */
10918 /* The arguments used to instantiate DECL, from the most general
10925 args = DECL_TI_ARGS (decl);
10926 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
10928 /* Unregister the specialization so that when we tsubst we will not
10929 just return DECL. We don't have to unregister DECL from TMPL
10930 because if would only be registered there if it were a partial
10931 instantiation of a specialization, which it isn't: it's a full
10933 gen_tmpl = most_general_template (tmpl);
10934 unregistered = reregister_specialization (decl, gen_tmpl,
10935 /*new_spec=*/NULL_TREE);
10937 /* If the DECL was not unregistered then something peculiar is
10938 happening: we created a specialization but did not call
10939 register_specialization for it. */
10940 my_friendly_assert (unregistered, 0);
10942 /* Make sure that we can see identifiers, and compute access
10944 push_access_scope (decl);
10946 /* Do the substitution to get the new declaration. */
10947 new_decl = tsubst (code_pattern, args, tf_error, NULL_TREE);
10949 if (TREE_CODE (decl) == VAR_DECL)
10951 /* Set up DECL_INITIAL, since tsubst doesn't. */
10952 if (!DECL_INITIALIZED_IN_CLASS_P (decl))
10953 DECL_INITIAL (new_decl) =
10954 tsubst_expr (DECL_INITIAL (code_pattern), args,
10955 tf_error, DECL_TI_TEMPLATE (decl));
10957 else if (TREE_CODE (decl) == FUNCTION_DECL)
10959 /* Convince duplicate_decls to use the DECL_ARGUMENTS from the
10961 DECL_INITIAL (new_decl) = error_mark_node;
10962 /* And don't complain about a duplicate definition. */
10963 DECL_INITIAL (decl) = NULL_TREE;
10966 pop_access_scope (decl);
10968 /* The immediate parent of the new template is still whatever it was
10969 before, even though tsubst sets DECL_TI_TEMPLATE up as the most
10970 general template. We also reset the DECL_ASSEMBLER_NAME since
10971 tsubst always calculates the name as if the function in question
10972 were really a template instance, and sometimes, with friend
10973 functions, this is not so. See tsubst_friend_function for
10975 DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl);
10976 COPY_DECL_ASSEMBLER_NAME (decl, new_decl);
10977 COPY_DECL_RTL (decl, new_decl);
10978 DECL_USE_TEMPLATE (new_decl) = DECL_USE_TEMPLATE (decl);
10980 /* Call duplicate decls to merge the old and new declarations. */
10981 duplicate_decls (new_decl, decl);
10983 /* Now, re-register the specialization. */
10984 register_specialization (decl, gen_tmpl, args);
10987 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
10988 substituted to get DECL. */
10991 template_for_substitution (tree decl)
10993 tree tmpl = DECL_TI_TEMPLATE (decl);
10995 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
10996 for the instantiation. This is not always the most general
10997 template. Consider, for example:
11000 struct S { template <class U> void f();
11001 template <> void f<int>(); };
11003 and an instantiation of S<double>::f<int>. We want TD to be the
11004 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11005 while (/* An instantiation cannot have a definition, so we need a
11006 more general template. */
11007 DECL_TEMPLATE_INSTANTIATION (tmpl)
11008 /* We must also deal with friend templates. Given:
11010 template <class T> struct S {
11011 template <class U> friend void f() {};
11014 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
11015 so far as the language is concerned, but that's still
11016 where we get the pattern for the instantiation from. On
11017 other hand, if the definition comes outside the class, say:
11019 template <class T> struct S {
11020 template <class U> friend void f();
11022 template <class U> friend void f() {}
11024 we don't need to look any further. That's what the check for
11025 DECL_INITIAL is for. */
11026 || (TREE_CODE (decl) == FUNCTION_DECL
11027 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
11028 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
11030 /* The present template, TD, should not be a definition. If it
11031 were a definition, we should be using it! Note that we
11032 cannot restructure the loop to just keep going until we find
11033 a template with a definition, since that might go too far if
11034 a specialization was declared, but not defined. */
11035 my_friendly_assert (!(TREE_CODE (decl) == VAR_DECL
11036 && !DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl))),
11039 /* Fetch the more general template. */
11040 tmpl = DECL_TI_TEMPLATE (tmpl);
11046 /* Produce the definition of D, a _DECL generated from a template. If
11047 DEFER_OK is nonzero, then we don't have to actually do the
11048 instantiation now; we just have to do it sometime. */
11051 instantiate_decl (tree d, int defer_ok)
11053 tree tmpl = DECL_TI_TEMPLATE (d);
11060 int pattern_defined;
11062 location_t saved_loc = input_location;
11064 /* This function should only be used to instantiate templates for
11065 functions and static member variables. */
11066 my_friendly_assert (TREE_CODE (d) == FUNCTION_DECL
11067 || TREE_CODE (d) == VAR_DECL, 0);
11069 /* Variables are never deferred; if instantiation is required, they
11070 are instantiated right away. That allows for better code in the
11071 case that an expression refers to the value of the variable --
11072 if the variable has a constant value the referring expression can
11073 take advantage of that fact. */
11074 if (TREE_CODE (d) == VAR_DECL)
11077 /* Don't instantiate cloned functions. Instead, instantiate the
11078 functions they cloned. */
11079 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
11080 d = DECL_CLONED_FUNCTION (d);
11082 if (DECL_TEMPLATE_INSTANTIATED (d))
11083 /* D has already been instantiated. It might seem reasonable to
11084 check whether or not D is an explicit instantiation, and, if so,
11085 stop here. But when an explicit instantiation is deferred
11086 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
11087 is set, even though we still need to do the instantiation. */
11090 /* If we already have a specialization of this declaration, then
11091 there's no reason to instantiate it. Note that
11092 retrieve_specialization gives us both instantiations and
11093 specializations, so we must explicitly check
11094 DECL_TEMPLATE_SPECIALIZATION. */
11095 gen_tmpl = most_general_template (tmpl);
11096 gen_args = DECL_TI_ARGS (d);
11097 spec = retrieve_specialization (gen_tmpl, gen_args);
11098 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
11101 /* This needs to happen before any tsubsting. */
11102 if (! push_tinst_level (d))
11105 timevar_push (TV_PARSE);
11107 /* We may be in the middle of deferred access check. Disable it now. */
11108 push_deferring_access_checks (dk_no_deferred);
11110 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
11111 for the instantiation. */
11112 td = template_for_substitution (d);
11113 code_pattern = DECL_TEMPLATE_RESULT (td);
11115 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
11116 || DECL_TEMPLATE_SPECIALIZATION (td))
11117 /* In the case of a friend template whose definition is provided
11118 outside the class, we may have too many arguments. Drop the
11119 ones we don't need. The same is true for specializations. */
11120 args = get_innermost_template_args
11121 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
11125 if (TREE_CODE (d) == FUNCTION_DECL)
11126 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
11128 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
11130 input_location = DECL_SOURCE_LOCATION (d);
11132 if (pattern_defined)
11134 /* Let the repository code that this template definition is
11137 The repository doesn't need to know about cloned functions
11138 because they never actually show up in the object file. It
11139 does need to know about the clones; those are the symbols
11140 that the linker will be emitting error messages about. */
11141 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (d)
11142 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (d))
11146 for (t = TREE_CHAIN (d);
11147 t && DECL_CLONED_FUNCTION_P (t);
11148 t = TREE_CHAIN (t))
11149 repo_template_used (t);
11152 repo_template_used (d);
11155 import_export_decl (d);
11160 /* Recheck the substitutions to obtain any warning messages
11161 about ignoring cv qualifiers. */
11162 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
11163 tree type = TREE_TYPE (gen);
11165 /* Make sure that we can see identifiers, and compute access
11166 correctly. D is already the target FUNCTION_DECL with the
11168 push_access_scope (d);
11170 if (TREE_CODE (gen) == FUNCTION_DECL)
11172 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_error | tf_warning, d);
11173 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
11174 tf_error | tf_warning, d);
11175 /* Don't simply tsubst the function type, as that will give
11176 duplicate warnings about poor parameter qualifications.
11177 The function arguments are the same as the decl_arguments
11178 without the top level cv qualifiers. */
11179 type = TREE_TYPE (type);
11181 tsubst (type, gen_args, tf_error | tf_warning, d);
11183 pop_access_scope (d);
11186 if (TREE_CODE (d) == VAR_DECL && DECL_INITIALIZED_IN_CLASS_P (d)
11187 && DECL_INITIAL (d) == NULL_TREE)
11188 /* We should have set up DECL_INITIAL in instantiate_class_template. */
11190 /* Reject all external templates except inline functions. */
11191 else if (DECL_INTERFACE_KNOWN (d)
11192 && ! DECL_NOT_REALLY_EXTERN (d)
11193 && ! (TREE_CODE (d) == FUNCTION_DECL
11194 && DECL_INLINE (d)))
11196 /* Defer all other templates, unless we have been explicitly
11197 forbidden from doing so. We restore the source position here
11198 because it's used by add_pending_template. */
11199 else if (! pattern_defined || defer_ok)
11201 input_location = saved_loc;
11203 if (at_eof && !pattern_defined
11204 && DECL_EXPLICIT_INSTANTIATION (d))
11207 The definition of a non-exported function template, a
11208 non-exported member function template, or a non-exported
11209 member function or static data member of a class template
11210 shall be present in every translation unit in which it is
11211 explicitly instantiated. */
11213 ("explicit instantiation of `%D' but no definition available", d);
11215 add_pending_template (d);
11219 need_push = !global_bindings_p ();
11221 push_to_top_level ();
11223 /* Mark D as instantiated so that recursive calls to
11224 instantiate_decl do not try to instantiate it again. */
11225 DECL_TEMPLATE_INSTANTIATED (d) = 1;
11227 /* Regenerate the declaration in case the template has been modified
11228 by a subsequent redeclaration. */
11229 regenerate_decl_from_template (d, td);
11231 /* We already set the file and line above. Reset them now in case
11232 they changed as a result of calling
11233 regenerate_decl_from_template. */
11234 input_location = DECL_SOURCE_LOCATION (d);
11236 if (TREE_CODE (d) == VAR_DECL)
11238 /* Clear out DECL_RTL; whatever was there before may not be right
11239 since we've reset the type of the declaration. */
11240 SET_DECL_RTL (d, NULL_RTX);
11242 DECL_IN_AGGR_P (d) = 0;
11243 import_export_decl (d);
11244 DECL_EXTERNAL (d) = ! DECL_NOT_REALLY_EXTERN (d);
11246 if (DECL_EXTERNAL (d))
11248 /* The fact that this code is executing indicates that:
11250 (1) D is a template static data member, for which a
11251 definition is available.
11253 (2) An implicit or explicit instantiation has occurred.
11255 (3) We are not going to emit a definition of the static
11256 data member at this time.
11258 This situation is peculiar, but it occurs on platforms
11259 without weak symbols when performing an implicit
11260 instantiation. There, we cannot implicitly instantiate a
11261 defined static data member in more than one translation
11262 unit, so import_export_decl marks the declaration as
11263 external; we must rely on explicit instantiation.
11265 Reset instantiated marker to make sure that later
11266 explicit instantiation will be processed. */
11267 DECL_TEMPLATE_INSTANTIATED (d) = 0;
11271 /* This is done in analogous to `start_decl'. It is
11272 required for correct access checking. */
11273 push_nested_class (DECL_CONTEXT (d));
11275 (!DECL_INITIALIZED_IN_CLASS_P (d)
11276 ? DECL_INITIAL (d) : NULL_TREE),
11278 /* Normally, pop_nested_class is called by cp_finish_decl
11279 above. But when instantiate_decl is triggered during
11280 instantiate_class_template processing, its DECL_CONTEXT
11281 is still not completed yet, and pop_nested_class isn't
11283 if (!COMPLETE_TYPE_P (DECL_CONTEXT (d)))
11284 pop_nested_class ();
11286 /* We're not deferring instantiation any more. */
11287 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
11289 else if (TREE_CODE (d) == FUNCTION_DECL)
11291 htab_t saved_local_specializations;
11296 /* Mark D as instantiated so that recursive calls to
11297 instantiate_decl do not try to instantiate it again. */
11298 DECL_TEMPLATE_INSTANTIATED (d) = 1;
11300 /* Save away the current list, in case we are instantiating one
11301 template from within the body of another. */
11302 saved_local_specializations = local_specializations;
11304 /* Set up the list of local specializations. */
11305 local_specializations = htab_create (37,
11306 hash_local_specialization,
11307 eq_local_specializations,
11310 /* Set up context. */
11311 import_export_decl (d);
11312 start_function (NULL_TREE, d, NULL_TREE, SF_PRE_PARSED);
11314 /* Create substitution entries for the parameters. */
11315 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
11316 tmpl_parm = DECL_ARGUMENTS (subst_decl);
11317 spec_parm = DECL_ARGUMENTS (d);
11318 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
11320 register_local_specialization (spec_parm, tmpl_parm);
11321 spec_parm = skip_artificial_parms_for (d, spec_parm);
11322 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
11326 register_local_specialization (spec_parm, tmpl_parm);
11327 tmpl_parm = TREE_CHAIN (tmpl_parm);
11328 spec_parm = TREE_CHAIN (spec_parm);
11330 my_friendly_assert (!spec_parm, 20020813);
11332 /* Substitute into the body of the function. */
11333 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
11334 tf_error | tf_warning, tmpl);
11336 /* We don't need the local specializations any more. */
11337 htab_delete (local_specializations);
11338 local_specializations = saved_local_specializations;
11340 /* We're not deferring instantiation any more. */
11341 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
11343 /* Finish the function. */
11344 d = finish_function (0);
11345 expand_or_defer_fn (d);
11349 pop_from_top_level ();
11352 input_location = saved_loc;
11353 pop_deferring_access_checks ();
11354 pop_tinst_level ();
11356 timevar_pop (TV_PARSE);
11361 /* Run through the list of templates that we wish we could
11362 instantiate, and instantiate any we can. */
11365 instantiate_pending_templates (void)
11368 tree last = NULL_TREE;
11369 int instantiated_something = 0;
11371 location_t saved_loc = input_location;
11377 t = &pending_templates;
11380 tree instantiation = TREE_VALUE (*t);
11382 reopen_tinst_level (TREE_PURPOSE (*t));
11384 if (TYPE_P (instantiation))
11388 if (!COMPLETE_TYPE_P (instantiation))
11390 instantiate_class_template (instantiation);
11391 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
11392 for (fn = TYPE_METHODS (instantiation);
11394 fn = TREE_CHAIN (fn))
11395 if (! DECL_ARTIFICIAL (fn))
11396 instantiate_decl (fn, /*defer_ok=*/0);
11397 if (COMPLETE_TYPE_P (instantiation))
11399 instantiated_something = 1;
11404 if (COMPLETE_TYPE_P (instantiation))
11405 /* If INSTANTIATION has been instantiated, then we don't
11406 need to consider it again in the future. */
11407 *t = TREE_CHAIN (*t);
11411 t = &TREE_CHAIN (*t);
11416 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
11417 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
11419 instantiation = instantiate_decl (instantiation,
11421 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
11423 instantiated_something = 1;
11428 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
11429 || DECL_TEMPLATE_INSTANTIATED (instantiation))
11430 /* If INSTANTIATION has been instantiated, then we don't
11431 need to consider it again in the future. */
11432 *t = TREE_CHAIN (*t);
11436 t = &TREE_CHAIN (*t);
11440 current_tinst_level = NULL_TREE;
11442 last_pending_template = last;
11444 while (reconsider);
11446 input_location = saved_loc;
11447 return instantiated_something;
11450 /* Substitute ARGVEC into T, which is a list of initializers for
11451 either base class or a non-static data member. The TREE_PURPOSEs
11452 are DECLs, and the TREE_VALUEs are the initializer values. Used by
11453 instantiate_decl. */
11456 tsubst_initializer_list (tree t, tree argvec)
11458 tree inits = NULL_TREE;
11460 for (; t; t = TREE_CHAIN (t))
11466 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_error | tf_warning,
11468 decl = expand_member_init (decl);
11469 if (decl && !DECL_P (decl))
11470 in_base_initializer = 1;
11472 init = tsubst_expr (TREE_VALUE (t), argvec, tf_error | tf_warning,
11476 else if (TREE_CODE (init) == TREE_LIST)
11477 for (val = init; val; val = TREE_CHAIN (val))
11478 TREE_VALUE (val) = convert_from_reference (TREE_VALUE (val));
11479 else if (init != void_type_node)
11480 init = convert_from_reference (init);
11482 in_base_initializer = 0;
11486 init = build_tree_list (decl, init);
11487 TREE_CHAIN (init) = inits;
11494 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
11497 set_current_access_from_decl (tree decl)
11499 if (TREE_PRIVATE (decl))
11500 current_access_specifier = access_private_node;
11501 else if (TREE_PROTECTED (decl))
11502 current_access_specifier = access_protected_node;
11504 current_access_specifier = access_public_node;
11507 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
11508 is the instantiation (which should have been created with
11509 start_enum) and ARGS are the template arguments to use. */
11512 tsubst_enum (tree tag, tree newtag, tree args)
11516 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
11521 decl = TREE_VALUE (e);
11522 /* Note that in a template enum, the TREE_VALUE is the
11523 CONST_DECL, not the corresponding INTEGER_CST. */
11524 value = tsubst_expr (DECL_INITIAL (decl),
11525 args, tf_error | tf_warning,
11528 /* Give this enumeration constant the correct access. */
11529 set_current_access_from_decl (decl);
11531 /* Actually build the enumerator itself. */
11532 build_enumerator (DECL_NAME (decl), value, newtag);
11535 finish_enum (newtag);
11536 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
11537 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
11540 /* DECL is a FUNCTION_DECL that is a template specialization. Return
11541 its type -- but without substituting the innermost set of template
11542 arguments. So, innermost set of template parameters will appear in
11546 get_mostly_instantiated_function_type (tree decl)
11554 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
11555 targs = DECL_TI_ARGS (decl);
11556 tparms = DECL_TEMPLATE_PARMS (tmpl);
11557 parm_depth = TMPL_PARMS_DEPTH (tparms);
11559 /* There should be as many levels of arguments as there are levels
11561 my_friendly_assert (parm_depth == TMPL_ARGS_DEPTH (targs), 0);
11563 fn_type = TREE_TYPE (tmpl);
11565 if (parm_depth == 1)
11566 /* No substitution is necessary. */
11573 /* Replace the innermost level of the TARGS with NULL_TREEs to
11574 let tsubst know not to substitute for those parameters. */
11575 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
11576 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
11577 SET_TMPL_ARGS_LEVEL (partial_args, i,
11578 TMPL_ARGS_LEVEL (targs, i));
11579 SET_TMPL_ARGS_LEVEL (partial_args,
11580 TMPL_ARGS_DEPTH (targs),
11581 make_tree_vec (DECL_NTPARMS (tmpl)));
11583 /* Make sure that we can see identifiers, and compute access
11584 correctly. We can just use the context of DECL for the
11585 partial substitution here. It depends only on outer template
11586 parameters, regardless of whether the innermost level is
11587 specialized or not. */
11588 push_access_scope (decl);
11590 ++processing_template_decl;
11591 /* Now, do the (partial) substitution to figure out the
11592 appropriate function type. */
11593 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
11594 --processing_template_decl;
11596 /* Substitute into the template parameters to obtain the real
11597 innermost set of parameters. This step is important if the
11598 innermost set of template parameters contains value
11599 parameters whose types depend on outer template parameters. */
11600 TREE_VEC_LENGTH (partial_args)--;
11601 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
11603 pop_access_scope (decl);
11609 /* Return truthvalue if we're processing a template different from
11610 the last one involved in diagnostics. */
11612 problematic_instantiation_changed (void)
11614 return last_template_error_tick != tinst_level_tick;
11617 /* Remember current template involved in diagnostics. */
11619 record_last_problematic_instantiation (void)
11621 last_template_error_tick = tinst_level_tick;
11625 current_instantiation (void)
11627 return current_tinst_level;
11630 /* [temp.param] Check that template non-type parm TYPE is of an allowable
11631 type. Return zero for ok, nonzero for disallowed. Issue error and
11632 warning messages under control of COMPLAIN. */
11635 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
11637 if (INTEGRAL_TYPE_P (type))
11639 else if (POINTER_TYPE_P (type))
11641 else if (TYPE_PTR_TO_MEMBER_P (type))
11643 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11645 else if (TREE_CODE (type) == TYPENAME_TYPE)
11648 if (complain & tf_error)
11649 error ("`%#T' is not a valid type for a template constant parameter",
11654 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
11655 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
11658 dependent_type_p_r (tree type)
11664 A type is dependent if it is:
11666 -- a template parameter. Template template parameters are
11667 types for us (since TYPE_P holds true for them) so we
11668 handle them here. */
11669 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
11670 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
11672 /* -- a qualified-id with a nested-name-specifier which contains a
11673 class-name that names a dependent type or whose unqualified-id
11674 names a dependent type. */
11675 if (TREE_CODE (type) == TYPENAME_TYPE)
11677 /* -- a cv-qualified type where the cv-unqualified type is
11679 type = TYPE_MAIN_VARIANT (type);
11680 /* -- a compound type constructed from any dependent type. */
11681 if (TYPE_PTR_TO_MEMBER_P (type))
11682 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
11683 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
11685 else if (TREE_CODE (type) == POINTER_TYPE
11686 || TREE_CODE (type) == REFERENCE_TYPE)
11687 return dependent_type_p (TREE_TYPE (type));
11688 else if (TREE_CODE (type) == FUNCTION_TYPE
11689 || TREE_CODE (type) == METHOD_TYPE)
11693 if (dependent_type_p (TREE_TYPE (type)))
11695 for (arg_type = TYPE_ARG_TYPES (type);
11697 arg_type = TREE_CHAIN (arg_type))
11698 if (dependent_type_p (TREE_VALUE (arg_type)))
11702 /* -- an array type constructed from any dependent type or whose
11703 size is specified by a constant expression that is
11704 value-dependent. */
11705 if (TREE_CODE (type) == ARRAY_TYPE)
11707 if (TYPE_DOMAIN (type)
11708 && ((value_dependent_expression_p
11709 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
11710 || (type_dependent_expression_p
11711 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
11713 return dependent_type_p (TREE_TYPE (type));
11716 /* -- a template-id in which either the template name is a template
11718 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
11720 /* ... or any of the template arguments is a dependent type or
11721 an expression that is type-dependent or value-dependent. */
11722 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
11723 && (any_dependent_template_arguments_p
11724 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
11727 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
11728 expression is not type-dependent, then it should already been
11730 if (TREE_CODE (type) == TYPEOF_TYPE)
11733 /* The standard does not specifically mention types that are local
11734 to template functions or local classes, but they should be
11735 considered dependent too. For example:
11737 template <int I> void f() {
11742 The size of `E' cannot be known until the value of `I' has been
11743 determined. Therefore, `E' must be considered dependent. */
11744 scope = TYPE_CONTEXT (type);
11745 if (scope && TYPE_P (scope))
11746 return dependent_type_p (scope);
11747 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
11748 return type_dependent_expression_p (scope);
11750 /* Other types are non-dependent. */
11754 /* Returns TRUE if TYPE is dependent, in the sense of
11755 [temp.dep.type]. */
11758 dependent_type_p (tree type)
11760 /* If there are no template parameters in scope, then there can't be
11761 any dependent types. */
11762 if (!processing_template_decl)
11765 /* If the type is NULL, we have not computed a type for the entity
11766 in question; in that case, the type is dependent. */
11770 /* Erroneous types can be considered non-dependent. */
11771 if (type == error_mark_node)
11774 /* If we have not already computed the appropriate value for TYPE,
11776 if (!TYPE_DEPENDENT_P_VALID (type))
11778 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
11779 TYPE_DEPENDENT_P_VALID (type) = 1;
11782 return TYPE_DEPENDENT_P (type);
11785 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
11788 dependent_scope_ref_p (tree expression, bool criterion (tree))
11793 my_friendly_assert (TREE_CODE (expression) == SCOPE_REF, 20030714);
11795 if (!TYPE_P (TREE_OPERAND (expression, 0)))
11798 scope = TREE_OPERAND (expression, 0);
11799 name = TREE_OPERAND (expression, 1);
11803 An id-expression is type-dependent if it contains a
11804 nested-name-specifier that contains a class-name that names a
11806 /* The suggested resolution to Core Issue 2 implies that if the
11807 qualifying type is the current class, then we must peek
11810 && currently_open_class (scope)
11811 && !criterion (name))
11813 if (dependent_type_p (scope))
11819 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
11820 [temp.dep.constexpr] */
11823 value_dependent_expression_p (tree expression)
11825 if (!processing_template_decl)
11828 /* A name declared with a dependent type. */
11829 if (TREE_CODE (expression) == IDENTIFIER_NODE
11830 || (DECL_P (expression)
11831 && type_dependent_expression_p (expression)))
11833 /* A non-type template parameter. */
11834 if ((TREE_CODE (expression) == CONST_DECL
11835 && DECL_TEMPLATE_PARM_P (expression))
11836 || TREE_CODE (expression) == TEMPLATE_PARM_INDEX)
11838 /* A constant with integral or enumeration type and is initialized
11839 with an expression that is value-dependent. */
11840 if (TREE_CODE (expression) == VAR_DECL
11841 && DECL_INITIAL (expression)
11842 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
11843 && value_dependent_expression_p (DECL_INITIAL (expression)))
11845 /* These expressions are value-dependent if the type to which the
11846 cast occurs is dependent or the expression being casted is
11847 value-dependent. */
11848 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
11849 || TREE_CODE (expression) == STATIC_CAST_EXPR
11850 || TREE_CODE (expression) == CONST_CAST_EXPR
11851 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
11852 || TREE_CODE (expression) == CAST_EXPR)
11854 tree type = TREE_TYPE (expression);
11855 if (dependent_type_p (type))
11857 /* A functional cast has a list of operands. */
11858 expression = TREE_OPERAND (expression, 0);
11861 /* If there are no operands, it must be an expression such
11862 as "int()". This should not happen for aggregate types
11863 because it would form non-constant expressions. */
11864 my_friendly_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type),
11869 if (TREE_CODE (expression) == TREE_LIST)
11873 if (value_dependent_expression_p (TREE_VALUE (expression)))
11875 expression = TREE_CHAIN (expression);
11877 while (expression);
11881 return value_dependent_expression_p (expression);
11883 /* A `sizeof' expression is value-dependent if the operand is
11885 if (TREE_CODE (expression) == SIZEOF_EXPR
11886 || TREE_CODE (expression) == ALIGNOF_EXPR)
11888 expression = TREE_OPERAND (expression, 0);
11889 if (TYPE_P (expression))
11890 return dependent_type_p (expression);
11891 return type_dependent_expression_p (expression);
11893 if (TREE_CODE (expression) == SCOPE_REF)
11894 return dependent_scope_ref_p (expression, value_dependent_expression_p);
11895 if (TREE_CODE (expression) == COMPONENT_REF)
11896 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
11897 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
11898 /* A constant expression is value-dependent if any subexpression is
11899 value-dependent. */
11900 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expression))))
11902 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
11905 return (value_dependent_expression_p
11906 (TREE_OPERAND (expression, 0)));
11909 return ((value_dependent_expression_p
11910 (TREE_OPERAND (expression, 0)))
11911 || (value_dependent_expression_p
11912 (TREE_OPERAND (expression, 1))));
11916 for (i = 0; i < first_rtl_op (TREE_CODE (expression)); ++i)
11917 /* In some cases, some of the operands may be missing.
11918 (For example, in the case of PREDECREMENT_EXPR, the
11919 amount to increment by may be missing.) That doesn't
11920 make the expression dependent. */
11921 if (TREE_OPERAND (expression, i)
11922 && (value_dependent_expression_p
11923 (TREE_OPERAND (expression, i))))
11930 /* The expression is not value-dependent. */
11934 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
11935 [temp.dep.expr]. */
11938 type_dependent_expression_p (tree expression)
11940 if (!processing_template_decl)
11943 if (expression == error_mark_node)
11946 /* An unresolved name is always dependent. */
11947 if (TREE_CODE (expression) == IDENTIFIER_NODE)
11950 /* Some expression forms are never type-dependent. */
11951 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
11952 || TREE_CODE (expression) == SIZEOF_EXPR
11953 || TREE_CODE (expression) == ALIGNOF_EXPR
11954 || TREE_CODE (expression) == TYPEID_EXPR
11955 || TREE_CODE (expression) == DELETE_EXPR
11956 || TREE_CODE (expression) == VEC_DELETE_EXPR
11957 || TREE_CODE (expression) == THROW_EXPR)
11960 /* The types of these expressions depends only on the type to which
11961 the cast occurs. */
11962 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
11963 || TREE_CODE (expression) == STATIC_CAST_EXPR
11964 || TREE_CODE (expression) == CONST_CAST_EXPR
11965 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
11966 || TREE_CODE (expression) == CAST_EXPR)
11967 return dependent_type_p (TREE_TYPE (expression));
11969 /* The types of these expressions depends only on the type created
11970 by the expression. */
11971 if (TREE_CODE (expression) == NEW_EXPR
11972 || TREE_CODE (expression) == VEC_NEW_EXPR)
11974 /* For NEW_EXPR tree nodes created inside a template, either
11975 the object type itself or a TREE_LIST may appear as the
11977 tree type = TREE_OPERAND (expression, 1);
11978 if (TREE_CODE (type) == TREE_LIST)
11979 /* This is an array type. We need to check array dimensions
11981 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
11982 || value_dependent_expression_p
11983 (TREE_OPERAND (TREE_VALUE (type), 1));
11985 return dependent_type_p (type);
11988 if (TREE_CODE (expression) == SCOPE_REF
11989 && dependent_scope_ref_p (expression,
11990 type_dependent_expression_p))
11993 if (TREE_CODE (expression) == FUNCTION_DECL
11994 && DECL_LANG_SPECIFIC (expression)
11995 && DECL_TEMPLATE_INFO (expression)
11996 && (any_dependent_template_arguments_p
11997 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
12000 if (TREE_CODE (expression) == TEMPLATE_DECL
12001 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
12004 if (TREE_TYPE (expression) == unknown_type_node)
12006 if (TREE_CODE (expression) == ADDR_EXPR)
12007 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
12008 if (TREE_CODE (expression) == COMPONENT_REF
12009 || TREE_CODE (expression) == OFFSET_REF)
12011 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
12013 expression = TREE_OPERAND (expression, 1);
12014 if (TREE_CODE (expression) == IDENTIFIER_NODE)
12017 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
12018 if (TREE_CODE (expression) == SCOPE_REF)
12021 if (TREE_CODE (expression) == BASELINK)
12022 expression = BASELINK_FUNCTIONS (expression);
12023 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
12025 if (any_dependent_template_arguments_p
12026 (TREE_OPERAND (expression, 1)))
12028 expression = TREE_OPERAND (expression, 0);
12030 if (TREE_CODE (expression) == OVERLOAD)
12034 if (type_dependent_expression_p (OVL_CURRENT (expression)))
12036 expression = OVL_NEXT (expression);
12043 return (dependent_type_p (TREE_TYPE (expression)));
12046 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
12047 contains a type-dependent expression. */
12050 any_type_dependent_arguments_p (tree args)
12054 tree arg = TREE_VALUE (args);
12056 if (type_dependent_expression_p (arg))
12058 args = TREE_CHAIN (args);
12063 /* Returns TRUE if the ARG (a template argument) is dependent. */
12066 dependent_template_arg_p (tree arg)
12068 if (!processing_template_decl)
12071 if (TREE_CODE (arg) == TEMPLATE_DECL
12072 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12073 return dependent_template_p (arg);
12074 else if (TYPE_P (arg))
12075 return dependent_type_p (arg);
12077 return (type_dependent_expression_p (arg)
12078 || value_dependent_expression_p (arg));
12081 /* Returns true if ARGS (a collection of template arguments) contains
12082 any dependent arguments. */
12085 any_dependent_template_arguments_p (tree args)
12093 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
12095 tree level = TMPL_ARGS_LEVEL (args, i + 1);
12096 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
12097 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
12104 /* Returns TRUE if the template TMPL is dependent. */
12107 dependent_template_p (tree tmpl)
12109 if (TREE_CODE (tmpl) == OVERLOAD)
12113 if (dependent_template_p (OVL_FUNCTION (tmpl)))
12115 tmpl = OVL_CHAIN (tmpl);
12120 /* Template template parameters are dependent. */
12121 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
12122 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
12124 /* So arenames that have not been looked up. */
12125 if (TREE_CODE (tmpl) == SCOPE_REF
12126 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
12128 /* So are member templates of dependent classes. */
12129 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
12130 return dependent_type_p (DECL_CONTEXT (tmpl));
12134 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
12137 dependent_template_id_p (tree tmpl, tree args)
12139 return (dependent_template_p (tmpl)
12140 || any_dependent_template_arguments_p (args));
12143 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
12144 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
12145 can be found. Note that this function peers inside uninstantiated
12146 templates and therefore should be used only in extremely limited
12150 resolve_typename_type (tree type, bool only_current_p)
12158 my_friendly_assert (TREE_CODE (type) == TYPENAME_TYPE,
12161 scope = TYPE_CONTEXT (type);
12162 name = TYPE_IDENTIFIER (type);
12164 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
12165 it first before we can figure out what NAME refers to. */
12166 if (TREE_CODE (scope) == TYPENAME_TYPE)
12167 scope = resolve_typename_type (scope, only_current_p);
12168 /* If we don't know what SCOPE refers to, then we cannot resolve the
12170 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
12171 return error_mark_node;
12172 /* If the SCOPE is a template type parameter, we have no way of
12173 resolving the name. */
12174 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
12176 /* If the SCOPE is not the current instantiation, there's no reason
12177 to look inside it. */
12178 if (only_current_p && !currently_open_class (scope))
12179 return error_mark_node;
12180 /* If SCOPE is a partial instantiation, it will not have a valid
12181 TYPE_FIELDS list, so use the original template. */
12182 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
12183 /* Enter the SCOPE so that name lookup will be resolved as if we
12184 were in the class definition. In particular, SCOPE will no
12185 longer be considered a dependent type. */
12186 pop_p = push_scope (scope);
12187 /* Look up the declaration. */
12188 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
12189 /* Obtain the set of qualifiers applied to the TYPE. */
12190 quals = cp_type_quals (type);
12191 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
12192 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
12194 type = error_mark_node;
12195 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
12196 && TREE_CODE (decl) == TYPE_DECL)
12197 type = TREE_TYPE (decl);
12198 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
12199 && DECL_CLASS_TEMPLATE_P (decl))
12203 /* Obtain the template and the arguments. */
12204 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
12205 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
12206 /* Instantiate the template. */
12207 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
12208 /*entering_scope=*/0, tf_error | tf_user);
12211 type = error_mark_node;
12212 /* Qualify the resulting type. */
12213 if (type != error_mark_node && quals)
12214 type = cp_build_qualified_type (type, quals);
12215 /* Leave the SCOPE. */
12222 /* EXPR is an expression which is not type-dependent. Return a proxy
12223 for EXPR that can be used to compute the types of larger
12224 expressions containing EXPR. */
12227 build_non_dependent_expr (tree expr)
12231 /* Preserve null pointer constants so that the type of things like
12232 "p == 0" where "p" is a pointer can be determined. */
12233 if (null_ptr_cst_p (expr))
12235 /* Preserve OVERLOADs; the functions must be available to resolve
12237 inner_expr = (TREE_CODE (expr) == ADDR_EXPR ?
12238 TREE_OPERAND (expr, 0) : expr);
12239 if (TREE_CODE (inner_expr) == OVERLOAD
12240 || TREE_CODE (inner_expr) == FUNCTION_DECL
12241 || TREE_CODE (inner_expr) == TEMPLATE_DECL
12242 || TREE_CODE (inner_expr) == TEMPLATE_ID_EXPR
12243 || TREE_CODE (inner_expr) == OFFSET_REF)
12245 /* Preserve string constants; conversions from string constants to
12246 "char *" are allowed, even though normally a "const char *"
12247 cannot be used to initialize a "char *". */
12248 if (TREE_CODE (expr) == STRING_CST)
12250 /* Preserve arithmetic constants, as an optimization -- there is no
12251 reason to create a new node. */
12252 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
12254 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
12255 There is at least one place where we want to know that a
12256 particular expression is a throw-expression: when checking a ?:
12257 expression, there are special rules if the second or third
12258 argument is a throw-expresion. */
12259 if (TREE_CODE (expr) == THROW_EXPR)
12262 if (TREE_CODE (expr) == COND_EXPR)
12263 return build (COND_EXPR,
12265 TREE_OPERAND (expr, 0),
12266 (TREE_OPERAND (expr, 1)
12267 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
12268 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
12269 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
12270 if (TREE_CODE (expr) == COMPOUND_EXPR
12271 && !COMPOUND_EXPR_OVERLOADED (expr))
12272 return build (COMPOUND_EXPR,
12274 TREE_OPERAND (expr, 0),
12275 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
12277 /* Otherwise, build a NON_DEPENDENT_EXPR.
12279 REFERENCE_TYPEs are not stripped for expressions in templates
12280 because doing so would play havoc with mangling. Consider, for
12283 template <typename T> void f<T& g>() { g(); }
12285 In the body of "f", the expression for "g" will have
12286 REFERENCE_TYPE, even though the standard says that it should
12287 not. The reason is that we must preserve the syntactic form of
12288 the expression so that mangling (say) "f<g>" inside the body of
12289 "f" works out correctly. Therefore, the REFERENCE_TYPE is
12291 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
12294 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
12295 Return a new TREE_LIST with the various arguments replaced with
12296 equivalent non-dependent expressions. */
12299 build_non_dependent_args (tree args)
12304 new_args = NULL_TREE;
12305 for (a = args; a; a = TREE_CHAIN (a))
12306 new_args = tree_cons (NULL_TREE,
12307 build_non_dependent_expr (TREE_VALUE (a)),
12309 return nreverse (new_args);
12312 #include "gt-cp-pt.h"