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, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, 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"
35 #include "pointer-set.h"
39 #include "cp-objcp-common.h"
40 #include "tree-inline.h"
47 #include "tree-iterator.h"
50 /* The type of functions taking a tree, and some additional data, and
52 typedef int (*tree_fn_t) (tree, void*);
54 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work.
57 The TREE_PURPOSE of each entry is either a DECL (for a function or
58 static data member), or a TYPE (for a class) indicating what we are
59 hoping to instantiate. The TREE_VALUE is not used. */
60 static GTY(()) tree pending_templates;
61 static GTY(()) tree last_pending_template;
63 int processing_template_parmlist;
64 static int template_header_count;
66 static GTY(()) tree saved_trees;
67 static VEC(int,heap) *inline_parm_levels;
69 static GTY(()) tree current_tinst_level;
71 static GTY(()) tree saved_access_scope;
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76 static tree cur_stmt_expr;
78 /* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
81 static htab_t local_specializations;
83 #define UNIFY_ALLOW_NONE 0
84 #define UNIFY_ALLOW_MORE_CV_QUAL 1
85 #define UNIFY_ALLOW_LESS_CV_QUAL 2
86 #define UNIFY_ALLOW_DERIVED 4
87 #define UNIFY_ALLOW_INTEGER 8
88 #define UNIFY_ALLOW_OUTER_LEVEL 16
89 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
90 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
92 static void push_access_scope (tree);
93 static void pop_access_scope (tree);
94 static int resolve_overloaded_unification (tree, tree, tree, tree,
95 unification_kind_t, int);
96 static int try_one_overload (tree, tree, tree, tree, tree,
97 unification_kind_t, int, bool);
98 static int unify (tree, tree, tree, tree, int);
99 static void add_pending_template (tree);
100 static int push_tinst_level (tree);
101 static void pop_tinst_level (void);
102 static void reopen_tinst_level (tree);
103 static tree classtype_mangled_name (tree);
104 static char* mangle_class_name_for_template (const char *, tree, tree);
105 static tree tsubst_initializer_list (tree, tree);
106 static tree get_class_bindings (tree, tree, tree);
107 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
109 static void tsubst_enum (tree, tree, tree);
110 static tree add_to_template_args (tree, tree);
111 static tree add_outermost_template_args (tree, tree);
112 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
113 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
114 static int type_unification_real (tree, tree, tree, tree,
115 int, unification_kind_t, int);
116 static void note_template_header (int);
117 static tree convert_nontype_argument_function (tree, tree);
118 static tree convert_nontype_argument (tree, tree);
119 static tree convert_template_argument (tree, tree, tree,
120 tsubst_flags_t, int, tree);
121 static int for_each_template_parm (tree, tree_fn_t, void*,
122 struct pointer_set_t*);
123 static tree build_template_parm_index (int, int, int, tree, tree);
124 static int inline_needs_template_parms (tree);
125 static void push_inline_template_parms_recursive (tree, int);
126 static tree retrieve_local_specialization (tree);
127 static void register_local_specialization (tree, tree);
128 static tree reduce_template_parm_level (tree, tree, int);
129 static int mark_template_parm (tree, void *);
130 static int template_parm_this_level_p (tree, void *);
131 static tree tsubst_friend_function (tree, tree);
132 static tree tsubst_friend_class (tree, tree);
133 static int can_complete_type_without_circularity (tree);
134 static tree get_bindings (tree, tree, tree, bool);
135 static int template_decl_level (tree);
136 static int check_cv_quals_for_unify (int, tree, tree);
137 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
138 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
139 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
140 static void regenerate_decl_from_template (tree, tree);
141 static tree most_specialized_class (tree, tree);
142 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
143 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
144 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
145 static bool check_specialization_scope (void);
146 static tree process_partial_specialization (tree);
147 static void set_current_access_from_decl (tree);
148 static void check_default_tmpl_args (tree, tree, int, int);
149 static tree get_template_base (tree, tree, tree, tree);
150 static tree try_class_unification (tree, tree, tree, tree);
151 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
153 static int template_args_equal (tree, tree);
154 static void tsubst_default_arguments (tree);
155 static tree for_each_template_parm_r (tree *, int *, void *);
156 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
157 static void copy_default_args_to_explicit_spec (tree);
158 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
159 static int eq_local_specializations (const void *, const void *);
160 static bool dependent_type_p_r (tree);
161 static tree tsubst (tree, tree, tsubst_flags_t, tree);
162 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
163 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
165 /* Make the current scope suitable for access checking when we are
166 processing T. T can be FUNCTION_DECL for instantiated function
167 template, or VAR_DECL for static member variable (need by
168 instantiate_decl). */
171 push_access_scope (tree t)
173 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
174 || TREE_CODE (t) == VAR_DECL);
176 if (DECL_FRIEND_CONTEXT (t))
177 push_nested_class (DECL_FRIEND_CONTEXT (t));
178 else if (DECL_CLASS_SCOPE_P (t))
179 push_nested_class (DECL_CONTEXT (t));
181 push_to_top_level ();
183 if (TREE_CODE (t) == FUNCTION_DECL)
185 saved_access_scope = tree_cons
186 (NULL_TREE, current_function_decl, saved_access_scope);
187 current_function_decl = t;
191 /* Restore the scope set up by push_access_scope. T is the node we
195 pop_access_scope (tree t)
197 if (TREE_CODE (t) == FUNCTION_DECL)
199 current_function_decl = TREE_VALUE (saved_access_scope);
200 saved_access_scope = TREE_CHAIN (saved_access_scope);
203 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
206 pop_from_top_level ();
209 /* Do any processing required when DECL (a member template
210 declaration) is finished. Returns the TEMPLATE_DECL corresponding
211 to DECL, unless it is a specialization, in which case the DECL
212 itself is returned. */
215 finish_member_template_decl (tree decl)
217 if (decl == error_mark_node)
218 return error_mark_node;
220 gcc_assert (DECL_P (decl));
222 if (TREE_CODE (decl) == TYPE_DECL)
226 type = TREE_TYPE (decl);
227 if (IS_AGGR_TYPE (type)
228 && CLASSTYPE_TEMPLATE_INFO (type)
229 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
231 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
232 check_member_template (tmpl);
237 else if (TREE_CODE (decl) == FIELD_DECL)
238 error ("data member %qD cannot be a member template", decl);
239 else if (DECL_TEMPLATE_INFO (decl))
241 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
243 check_member_template (DECL_TI_TEMPLATE (decl));
244 return DECL_TI_TEMPLATE (decl);
250 error ("invalid member template declaration %qD", decl);
252 return error_mark_node;
255 /* Returns the template nesting level of the indicated class TYPE.
265 A<T>::B<U> has depth two, while A<T> has depth one.
266 Both A<T>::B<int> and A<int>::B<U> have depth one, if
267 they are instantiations, not specializations.
269 This function is guaranteed to return 0 if passed NULL_TREE so
270 that, for example, `template_class_depth (current_class_type)' is
274 template_class_depth (tree type)
279 type && TREE_CODE (type) != NAMESPACE_DECL;
280 type = (TREE_CODE (type) == FUNCTION_DECL)
281 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
283 if (TREE_CODE (type) != FUNCTION_DECL)
285 if (CLASSTYPE_TEMPLATE_INFO (type)
286 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
287 && uses_template_parms (CLASSTYPE_TI_ARGS (type)))
292 if (DECL_TEMPLATE_INFO (type)
293 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
294 && uses_template_parms (DECL_TI_ARGS (type)))
302 /* Returns 1 if processing DECL as part of do_pending_inlines
303 needs us to push template parms. */
306 inline_needs_template_parms (tree decl)
308 if (! DECL_TEMPLATE_INFO (decl))
311 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
312 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
315 /* Subroutine of maybe_begin_member_template_processing.
316 Push the template parms in PARMS, starting from LEVELS steps into the
317 chain, and ending at the beginning, since template parms are listed
321 push_inline_template_parms_recursive (tree parmlist, int levels)
323 tree parms = TREE_VALUE (parmlist);
327 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
329 ++processing_template_decl;
330 current_template_parms
331 = tree_cons (size_int (processing_template_decl),
332 parms, current_template_parms);
333 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
335 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
337 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
339 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
341 if (parm == error_mark_node)
344 gcc_assert (DECL_P (parm));
346 switch (TREE_CODE (parm))
355 /* Make a CONST_DECL as is done in process_template_parm.
356 It is ugly that we recreate this here; the original
357 version built in process_template_parm is no longer
359 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
361 DECL_ARTIFICIAL (decl) = 1;
362 TREE_CONSTANT (decl) = 1;
363 TREE_INVARIANT (decl) = 1;
364 TREE_READONLY (decl) = 1;
365 DECL_INITIAL (decl) = DECL_INITIAL (parm);
366 SET_DECL_TEMPLATE_PARM_P (decl);
377 /* Restore the template parameter context for a member template or
378 a friend template defined in a class definition. */
381 maybe_begin_member_template_processing (tree decl)
386 if (inline_needs_template_parms (decl))
388 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
389 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
391 if (DECL_TEMPLATE_SPECIALIZATION (decl))
394 parms = TREE_CHAIN (parms);
397 push_inline_template_parms_recursive (parms, levels);
400 /* Remember how many levels of template parameters we pushed so that
401 we can pop them later. */
402 VEC_safe_push (int, heap, inline_parm_levels, levels);
405 /* Undo the effects of maybe_begin_member_template_processing. */
408 maybe_end_member_template_processing (void)
413 if (VEC_length (int, inline_parm_levels) == 0)
416 last = VEC_pop (int, inline_parm_levels);
417 for (i = 0; i < last; ++i)
419 --processing_template_decl;
420 current_template_parms = TREE_CHAIN (current_template_parms);
425 /* Return a new template argument vector which contains all of ARGS,
426 but has as its innermost set of arguments the EXTRA_ARGS. */
429 add_to_template_args (tree args, tree extra_args)
436 extra_depth = TMPL_ARGS_DEPTH (extra_args);
437 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
439 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
440 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
442 for (j = 1; j <= extra_depth; ++j, ++i)
443 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
448 /* Like add_to_template_args, but only the outermost ARGS are added to
449 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
450 (EXTRA_ARGS) levels are added. This function is used to combine
451 the template arguments from a partial instantiation with the
452 template arguments used to attain the full instantiation from the
453 partial instantiation. */
456 add_outermost_template_args (tree args, tree extra_args)
460 /* If there are more levels of EXTRA_ARGS than there are ARGS,
461 something very fishy is going on. */
462 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
464 /* If *all* the new arguments will be the EXTRA_ARGS, just return
466 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
469 /* For the moment, we make ARGS look like it contains fewer levels. */
470 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
472 new_args = add_to_template_args (args, extra_args);
474 /* Now, we restore ARGS to its full dimensions. */
475 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
480 /* Return the N levels of innermost template arguments from the ARGS. */
483 get_innermost_template_args (tree args, int n)
491 /* If N is 1, just return the innermost set of template arguments. */
493 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
495 /* If we're not removing anything, just return the arguments we were
497 extra_levels = TMPL_ARGS_DEPTH (args) - n;
498 gcc_assert (extra_levels >= 0);
499 if (extra_levels == 0)
502 /* Make a new set of arguments, not containing the outer arguments. */
503 new_args = make_tree_vec (n);
504 for (i = 1; i <= n; ++i)
505 SET_TMPL_ARGS_LEVEL (new_args, i,
506 TMPL_ARGS_LEVEL (args, i + extra_levels));
511 /* We've got a template header coming up; push to a new level for storing
515 begin_template_parm_list (void)
517 /* We use a non-tag-transparent scope here, which causes pushtag to
518 put tags in this scope, rather than in the enclosing class or
519 namespace scope. This is the right thing, since we want
520 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
521 global template class, push_template_decl handles putting the
522 TEMPLATE_DECL into top-level scope. For a nested template class,
525 template <class T> struct S1 {
526 template <class T> struct S2 {};
529 pushtag contains special code to call pushdecl_with_scope on the
530 TEMPLATE_DECL for S2. */
531 begin_scope (sk_template_parms, NULL);
532 ++processing_template_decl;
533 ++processing_template_parmlist;
534 note_template_header (0);
537 /* This routine is called when a specialization is declared. If it is
538 invalid to declare a specialization here, an error is reported and
539 false is returned, otherwise this routine will return true. */
542 check_specialization_scope (void)
544 tree scope = current_scope ();
548 An explicit specialization shall be declared in the namespace of
549 which the template is a member, or, for member templates, in the
550 namespace of which the enclosing class or enclosing class
551 template is a member. An explicit specialization of a member
552 function, member class or static data member of a class template
553 shall be declared in the namespace of which the class template
555 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
557 error ("explicit specialization in non-namespace scope %qD", scope);
563 In an explicit specialization declaration for a member of a class
564 template or a member template that appears in namespace scope,
565 the member template and some of its enclosing class templates may
566 remain unspecialized, except that the declaration shall not
567 explicitly specialize a class member template if its enclosing
568 class templates are not explicitly specialized as well. */
569 if (current_template_parms)
571 error ("enclosing class templates are not explicitly specialized");
578 /* We've just seen template <>. */
581 begin_specialization (void)
583 begin_scope (sk_template_spec, NULL);
584 note_template_header (1);
585 return check_specialization_scope ();
588 /* Called at then end of processing a declaration preceded by
592 end_specialization (void)
595 reset_specialization ();
598 /* Any template <>'s that we have seen thus far are not referring to a
599 function specialization. */
602 reset_specialization (void)
604 processing_specialization = 0;
605 template_header_count = 0;
608 /* We've just seen a template header. If SPECIALIZATION is nonzero,
609 it was of the form template <>. */
612 note_template_header (int specialization)
614 processing_specialization = specialization;
615 template_header_count++;
618 /* We're beginning an explicit instantiation. */
621 begin_explicit_instantiation (void)
623 gcc_assert (!processing_explicit_instantiation);
624 processing_explicit_instantiation = true;
629 end_explicit_instantiation (void)
631 gcc_assert (processing_explicit_instantiation);
632 processing_explicit_instantiation = false;
635 /* An explicit specialization or partial specialization TMPL is being
636 declared. Check that the namespace in which the specialization is
637 occurring is permissible. Returns false iff it is invalid to
638 specialize TMPL in the current namespace. */
641 check_specialization_namespace (tree tmpl)
643 tree tpl_ns = decl_namespace_context (tmpl);
647 An explicit specialization shall be declared in the namespace of
648 which the template is a member, or, for member templates, in the
649 namespace of which the enclosing class or enclosing class
650 template is a member. An explicit specialization of a member
651 function, member class or static data member of a class template
652 shall be declared in the namespace of which the class template is
654 if (is_associated_namespace (current_namespace, tpl_ns))
655 /* Same or super-using namespace. */
659 pedwarn ("specialization of %qD in different namespace", tmpl);
660 pedwarn (" from definition of %q+#D", tmpl);
665 /* SPEC is an explicit instantiation. Check that it is valid to
666 perform this explicit instantiation in the current namespace. */
669 check_explicit_instantiation_namespace (tree spec)
673 /* DR 275: An explicit instantiation shall appear in an enclosing
674 namespace of its template. */
675 ns = decl_namespace_context (spec);
676 if (!is_ancestor (current_namespace, ns))
677 pedwarn ("explicit instantiation of %qD in namespace %qD "
678 "(which does not enclose namespace %qD)",
679 spec, current_namespace, ns);
682 /* The TYPE is being declared. If it is a template type, that means it
683 is a partial specialization. Do appropriate error-checking. */
686 maybe_process_partial_specialization (tree type)
690 if (type == error_mark_node)
691 return error_mark_node;
693 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
695 error ("name of class shadows template template parameter %qD",
697 return error_mark_node;
700 context = TYPE_CONTEXT (type);
702 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
704 /* This is for ordinary explicit specialization and partial
705 specialization of a template class such as:
707 template <> class C<int>;
711 template <class T> class C<T*>;
713 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
715 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
716 && !COMPLETE_TYPE_P (type))
718 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
719 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
720 if (processing_template_decl)
721 push_template_decl (TYPE_MAIN_DECL (type));
723 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
724 error ("specialization of %qT after instantiation", type);
726 else if (CLASS_TYPE_P (type)
727 && !CLASSTYPE_USE_TEMPLATE (type)
728 && CLASSTYPE_TEMPLATE_INFO (type)
729 && context && CLASS_TYPE_P (context)
730 && CLASSTYPE_TEMPLATE_INFO (context))
732 /* This is for an explicit specialization of member class
733 template according to [temp.expl.spec/18]:
735 template <> template <class U> class C<int>::D;
737 The context `C<int>' must be an implicit instantiation.
738 Otherwise this is just a member class template declared
741 template <> class C<int> { template <class U> class D; };
742 template <> template <class U> class C<int>::D;
744 In the first case, `C<int>::D' is a specialization of `C<T>::D'
745 while in the second case, `C<int>::D' is a primary template
746 and `C<T>::D' may not exist. */
748 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
749 && !COMPLETE_TYPE_P (type))
753 if (current_namespace
754 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
756 pedwarn ("specializing %q#T in different namespace", type);
757 pedwarn (" from definition of %q+#D",
758 CLASSTYPE_TI_TEMPLATE (type));
761 /* Check for invalid specialization after instantiation:
763 template <> template <> class C<int>::D<int>;
764 template <> template <class U> class C<int>::D; */
766 for (t = DECL_TEMPLATE_INSTANTIATIONS
767 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
768 t; t = TREE_CHAIN (t))
769 if (TREE_VALUE (t) != type
770 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
771 error ("specialization %qT after instantiation %qT",
772 type, TREE_VALUE (t));
774 /* Mark TYPE as a specialization. And as a result, we only
775 have one level of template argument for the innermost
777 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
778 CLASSTYPE_TI_ARGS (type)
779 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
782 else if (processing_specialization)
784 error ("explicit specialization of non-template %qT", type);
785 return error_mark_node;
791 /* Returns nonzero if we can optimize the retrieval of specializations
792 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
793 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
796 optimize_specialization_lookup_p (tree tmpl)
798 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
799 && DECL_CLASS_SCOPE_P (tmpl)
800 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
802 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
803 /* The optimized lookup depends on the fact that the
804 template arguments for the member function template apply
805 purely to the containing class, which is not true if the
806 containing class is an explicit or partial
808 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
809 && !DECL_MEMBER_TEMPLATE_P (tmpl)
810 && !DECL_CONV_FN_P (tmpl)
811 /* It is possible to have a template that is not a member
812 template and is not a member of a template class:
814 template <typename T>
815 struct S { friend A::f(); };
817 Here, the friend function is a template, but the context does
818 not have template information. The optimized lookup relies
819 on having ARGS be the template arguments for both the class
820 and the function template. */
821 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
824 /* Retrieve the specialization (in the sense of [temp.spec] - a
825 specialization is either an instantiation or an explicit
826 specialization) of TMPL for the given template ARGS. If there is
827 no such specialization, return NULL_TREE. The ARGS are a vector of
828 arguments, or a vector of vectors of arguments, in the case of
829 templates with more than one level of parameters.
831 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
832 then we search for a partial specialization matching ARGS. This
833 parameter is ignored if TMPL is not a class template. */
836 retrieve_specialization (tree tmpl, tree args,
837 bool class_specializations_p)
839 if (args == error_mark_node)
842 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
844 /* There should be as many levels of arguments as there are
845 levels of parameters. */
846 gcc_assert (TMPL_ARGS_DEPTH (args)
847 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
849 if (optimize_specialization_lookup_p (tmpl))
852 tree class_specialization;
853 VEC(tree,gc) *methods;
857 /* The template arguments actually apply to the containing
858 class. Find the class specialization with those
860 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
862 = retrieve_specialization (class_template, args,
863 /*class_specializations_p=*/false);
864 if (!class_specialization)
866 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
867 for the specialization. */
868 idx = class_method_index_for_fn (class_specialization, tmpl);
871 /* Iterate through the methods with the indicated name, looking
872 for the one that has an instance of TMPL. */
873 methods = CLASSTYPE_METHOD_VEC (class_specialization);
874 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
876 tree fn = OVL_CURRENT (fns);
877 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
887 /* Class templates store their instantiations on the
888 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
889 DECL_TEMPLATE_SPECIALIZATIONS list. */
890 if (!class_specializations_p
891 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
892 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
894 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
896 /* Iterate through the list until we find a matching template. */
897 while (*sp != NULL_TREE)
901 if (comp_template_args (TREE_PURPOSE (spec), args))
903 /* Use the move-to-front heuristic to speed up future
907 *sp = TREE_CHAIN (*sp);
908 TREE_CHAIN (spec) = *head;
911 return TREE_VALUE (spec);
913 sp = &TREE_CHAIN (spec);
920 /* Like retrieve_specialization, but for local declarations. */
923 retrieve_local_specialization (tree tmpl)
925 tree spec = (tree) htab_find_with_hash (local_specializations, tmpl,
926 htab_hash_pointer (tmpl));
927 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
930 /* Returns nonzero iff DECL is a specialization of TMPL. */
933 is_specialization_of (tree decl, tree tmpl)
937 if (TREE_CODE (decl) == FUNCTION_DECL)
941 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
947 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
949 for (t = TREE_TYPE (decl);
951 t = CLASSTYPE_USE_TEMPLATE (t)
952 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
953 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
960 /* Returns nonzero iff DECL is a specialization of friend declaration
961 FRIEND according to [temp.friend]. */
964 is_specialization_of_friend (tree decl, tree friend)
966 bool need_template = true;
969 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
970 || TREE_CODE (decl) == TYPE_DECL);
972 /* For [temp.friend/6] when FRIEND is an ordinary member function
973 of a template class, we want to check if DECL is a specialization
975 if (TREE_CODE (friend) == FUNCTION_DECL
976 && DECL_TEMPLATE_INFO (friend)
977 && !DECL_USE_TEMPLATE (friend))
979 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
980 friend = DECL_TI_TEMPLATE (friend);
981 need_template = false;
983 else if (TREE_CODE (friend) == TEMPLATE_DECL
984 && !PRIMARY_TEMPLATE_P (friend))
985 need_template = false;
987 /* There is nothing to do if this is not a template friend. */
988 if (TREE_CODE (friend) != TEMPLATE_DECL)
991 if (is_specialization_of (decl, friend))
995 A member of a class template may be declared to be a friend of a
996 non-template class. In this case, the corresponding member of
997 every specialization of the class template is a friend of the
998 class granting friendship.
1000 For example, given a template friend declaration
1002 template <class T> friend void A<T>::f();
1004 the member function below is considered a friend
1006 template <> struct A<int> {
1010 For this type of template friend, TEMPLATE_DEPTH below will be
1011 nonzero. To determine if DECL is a friend of FRIEND, we first
1012 check if the enclosing class is a specialization of another. */
1014 template_depth = template_class_depth (DECL_CONTEXT (friend));
1016 && DECL_CLASS_SCOPE_P (decl)
1017 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1018 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1020 /* Next, we check the members themselves. In order to handle
1021 a few tricky cases, such as when FRIEND's are
1023 template <class T> friend void A<T>::g(T t);
1024 template <class T> template <T t> friend void A<T>::h();
1028 void A<int>::g(int);
1029 template <int> void A<int>::h();
1031 we need to figure out ARGS, the template arguments from
1032 the context of DECL. This is required for template substitution
1033 of `T' in the function parameter of `g' and template parameter
1034 of `h' in the above examples. Here ARGS corresponds to `int'. */
1036 tree context = DECL_CONTEXT (decl);
1037 tree args = NULL_TREE;
1038 int current_depth = 0;
1040 while (current_depth < template_depth)
1042 if (CLASSTYPE_TEMPLATE_INFO (context))
1044 if (current_depth == 0)
1045 args = TYPE_TI_ARGS (context);
1047 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1050 context = TYPE_CONTEXT (context);
1053 if (TREE_CODE (decl) == FUNCTION_DECL)
1058 tree friend_args_type;
1059 tree decl_args_type;
1061 /* Make sure that both DECL and FRIEND are templates or
1063 is_template = DECL_TEMPLATE_INFO (decl)
1064 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1065 if (need_template ^ is_template)
1067 else if (is_template)
1069 /* If both are templates, check template parameter list. */
1071 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1073 if (!comp_template_parms
1074 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1078 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1081 decl_type = TREE_TYPE (decl);
1083 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1084 tf_none, NULL_TREE);
1085 if (friend_type == error_mark_node)
1088 /* Check if return types match. */
1089 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1092 /* Check if function parameter types match, ignoring the
1093 `this' parameter. */
1094 friend_args_type = TYPE_ARG_TYPES (friend_type);
1095 decl_args_type = TYPE_ARG_TYPES (decl_type);
1096 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1097 friend_args_type = TREE_CHAIN (friend_args_type);
1098 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1099 decl_args_type = TREE_CHAIN (decl_args_type);
1101 return compparms (decl_args_type, friend_args_type);
1105 /* DECL is a TYPE_DECL */
1107 tree decl_type = TREE_TYPE (decl);
1109 /* Make sure that both DECL and FRIEND are templates or
1112 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1113 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1115 if (need_template ^ is_template)
1117 else if (is_template)
1120 /* If both are templates, check the name of the two
1121 TEMPLATE_DECL's first because is_friend didn't. */
1122 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1123 != DECL_NAME (friend))
1126 /* Now check template parameter list. */
1128 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1130 return comp_template_parms
1131 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1135 return (DECL_NAME (decl)
1136 == DECL_NAME (friend));
1142 /* Register the specialization SPEC as a specialization of TMPL with
1143 the indicated ARGS. IS_FRIEND indicates whether the specialization
1144 is actually just a friend declaration. Returns SPEC, or an
1145 equivalent prior declaration, if available. */
1148 register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1152 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1154 if (TREE_CODE (spec) == FUNCTION_DECL
1155 && uses_template_parms (DECL_TI_ARGS (spec)))
1156 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1157 register it; we want the corresponding TEMPLATE_DECL instead.
1158 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1159 the more obvious `uses_template_parms (spec)' to avoid problems
1160 with default function arguments. In particular, given
1161 something like this:
1163 template <class T> void f(T t1, T t = T())
1165 the default argument expression is not substituted for in an
1166 instantiation unless and until it is actually needed. */
1169 fn = retrieve_specialization (tmpl, args,
1170 /*class_specializations_p=*/false);
1171 /* We can sometimes try to re-register a specialization that we've
1172 already got. In particular, regenerate_decl_from_template calls
1173 duplicate_decls which will update the specialization list. But,
1174 we'll still get called again here anyhow. It's more convenient
1175 to simply allow this than to try to prevent it. */
1178 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1180 if (DECL_TEMPLATE_INSTANTIATION (fn))
1183 || DECL_EXPLICIT_INSTANTIATION (fn))
1185 error ("specialization of %qD after instantiation",
1187 return error_mark_node;
1192 /* This situation should occur only if the first
1193 specialization is an implicit instantiation, the
1194 second is an explicit specialization, and the
1195 implicit instantiation has not yet been used. That
1196 situation can occur if we have implicitly
1197 instantiated a member function and then specialized
1200 We can also wind up here if a friend declaration that
1201 looked like an instantiation turns out to be a
1204 template <class T> void foo(T);
1205 class S { friend void foo<>(int) };
1206 template <> void foo(int);
1208 We transform the existing DECL in place so that any
1209 pointers to it become pointers to the updated
1212 If there was a definition for the template, but not
1213 for the specialization, we want this to look as if
1214 there were no definition, and vice versa. */
1215 DECL_INITIAL (fn) = NULL_TREE;
1216 duplicate_decls (spec, fn, is_friend);
1217 /* The call to duplicate_decls will have applied
1220 An explicit specialization of a function template
1221 is inline only if it is explicitly declared to be,
1222 and independently of whether its function template
1225 to the primary function; now copy the inline bits to
1226 the various clones. */
1227 FOR_EACH_CLONE (clone, fn)
1229 DECL_DECLARED_INLINE_P (clone)
1230 = DECL_DECLARED_INLINE_P (fn);
1234 check_specialization_namespace (fn);
1239 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1241 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1242 /* Dup decl failed, but this is a new definition. Set the
1243 line number so any errors match this new
1245 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1251 /* A specialization must be declared in the same namespace as the
1252 template it is specializing. */
1253 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1254 && !check_specialization_namespace (tmpl))
1255 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1257 if (!optimize_specialization_lookup_p (tmpl))
1258 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1259 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1264 /* Unregister the specialization SPEC as a specialization of TMPL.
1265 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1266 if the SPEC was listed as a specialization of TMPL. */
1269 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1273 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1275 s = &TREE_CHAIN (*s))
1276 if (TREE_VALUE (*s) == spec)
1279 *s = TREE_CHAIN (*s);
1281 TREE_VALUE (*s) = new_spec;
1288 /* Compare an entry in the local specializations hash table P1 (which
1289 is really a pointer to a TREE_LIST) with P2 (which is really a
1293 eq_local_specializations (const void *p1, const void *p2)
1295 return TREE_VALUE ((tree) p1) == (tree) p2;
1298 /* Hash P1, an entry in the local specializations table. */
1301 hash_local_specialization (const void* p1)
1303 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1306 /* Like register_specialization, but for local declarations. We are
1307 registering SPEC, an instantiation of TMPL. */
1310 register_local_specialization (tree spec, tree tmpl)
1314 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1315 htab_hash_pointer (tmpl), INSERT);
1316 *slot = build_tree_list (spec, tmpl);
1319 /* Print the list of candidate FNS in an error message. */
1322 print_candidates (tree fns)
1326 const char *str = "candidates are:";
1328 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1332 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1333 error ("%s %+#D", str, OVL_CURRENT (f));
1338 /* Returns the template (one of the functions given by TEMPLATE_ID)
1339 which can be specialized to match the indicated DECL with the
1340 explicit template args given in TEMPLATE_ID. The DECL may be
1341 NULL_TREE if none is available. In that case, the functions in
1342 TEMPLATE_ID are non-members.
1344 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1345 specialization of a member template.
1347 The TEMPLATE_COUNT is the number of references to qualifying
1348 template classes that appeared in the name of the function. See
1349 check_explicit_specialization for a more accurate description.
1351 TSK indicates what kind of template declaration (if any) is being
1352 declared. TSK_TEMPLATE indicates that the declaration given by
1353 DECL, though a FUNCTION_DECL, has template parameters, and is
1354 therefore a template function.
1356 The template args (those explicitly specified and those deduced)
1357 are output in a newly created vector *TARGS_OUT.
1359 If it is impossible to determine the result, an error message is
1360 issued. The error_mark_node is returned to indicate failure. */
1363 determine_specialization (tree template_id,
1366 int need_member_template,
1372 tree explicit_targs;
1373 tree candidates = NULL_TREE;
1374 /* A TREE_LIST of templates of which DECL may be a specialization.
1375 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1376 corresponding TREE_PURPOSE is the set of template arguments that,
1377 when used to instantiate the template, would produce a function
1378 with the signature of DECL. */
1379 tree templates = NULL_TREE;
1381 struct cp_binding_level *b;
1383 *targs_out = NULL_TREE;
1385 if (template_id == error_mark_node || decl == error_mark_node)
1386 return error_mark_node;
1388 fns = TREE_OPERAND (template_id, 0);
1389 explicit_targs = TREE_OPERAND (template_id, 1);
1391 if (fns == error_mark_node)
1392 return error_mark_node;
1394 /* Check for baselinks. */
1395 if (BASELINK_P (fns))
1396 fns = BASELINK_FUNCTIONS (fns);
1398 if (!is_overloaded_fn (fns))
1400 error ("%qD is not a function template", fns);
1401 return error_mark_node;
1404 /* Count the number of template headers specified for this
1407 for (b = current_binding_level;
1408 b->kind == sk_template_parms;
1412 for (; fns; fns = OVL_NEXT (fns))
1414 tree fn = OVL_CURRENT (fns);
1416 if (TREE_CODE (fn) == TEMPLATE_DECL)
1418 tree decl_arg_types;
1421 /* DECL might be a specialization of FN. */
1423 /* Adjust the type of DECL in case FN is a static member. */
1424 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1425 if (DECL_STATIC_FUNCTION_P (fn)
1426 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1427 decl_arg_types = TREE_CHAIN (decl_arg_types);
1429 /* Check that the number of function parameters matches.
1431 template <class T> void f(int i = 0);
1432 template <> void f<int>();
1433 The specialization f<int> is invalid but is not caught
1434 by get_bindings below. */
1436 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1437 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1440 /* For a non-static member function, we need to make sure that
1441 the const qualification is the same. This can be done by
1442 checking the 'this' in the argument list. */
1443 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1444 && !same_type_p (TREE_VALUE (fn_arg_types),
1445 TREE_VALUE (decl_arg_types)))
1448 /* In case of explicit specialization, we need to check if
1449 the number of template headers appearing in the specialization
1450 is correct. This is usually done in check_explicit_specialization,
1451 but the check done there cannot be exhaustive when specializing
1452 member functions. Consider the following code:
1454 template <> void A<int>::f(int);
1455 template <> template <> void A<int>::f(int);
1457 Assuming that A<int> is not itself an explicit specialization
1458 already, the first line specializes "f" which is a non-template
1459 member function, whilst the second line specializes "f" which
1460 is a template member function. So both lines are syntactically
1461 correct, and check_explicit_specialization does not reject
1464 Here, we can do better, as we are matching the specialization
1465 against the declarations. We count the number of template
1466 headers, and we check if they match TEMPLATE_COUNT + 1
1467 (TEMPLATE_COUNT is the number of qualifying template classes,
1468 plus there must be another header for the member template
1471 Notice that if header_count is zero, this is not a
1472 specialization but rather a template instantiation, so there
1473 is no check we can perform here. */
1474 if (header_count && header_count != template_count + 1)
1477 /* Check that the number of template arguments at the
1478 innermost level for DECL is the same as for FN. */
1479 if (current_binding_level->kind == sk_template_parms
1480 && !current_binding_level->explicit_spec_p
1481 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1482 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1483 (current_template_parms))))
1486 /* Function templates cannot be specializations; there are
1487 no partial specializations of functions. Therefore, if
1488 the type of DECL does not match FN, there is no
1490 if (tsk == tsk_template)
1492 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1494 candidates = tree_cons (NULL_TREE, fn, candidates);
1498 /* See whether this function might be a specialization of this
1500 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1503 /* We cannot deduce template arguments that when used to
1504 specialize TMPL will produce DECL. */
1507 /* Save this template, and the arguments deduced. */
1508 templates = tree_cons (targs, fn, templates);
1510 else if (need_member_template)
1511 /* FN is an ordinary member function, and we need a
1512 specialization of a member template. */
1514 else if (TREE_CODE (fn) != FUNCTION_DECL)
1515 /* We can get IDENTIFIER_NODEs here in certain erroneous
1518 else if (!DECL_FUNCTION_MEMBER_P (fn))
1519 /* This is just an ordinary non-member function. Nothing can
1520 be a specialization of that. */
1522 else if (DECL_ARTIFICIAL (fn))
1523 /* Cannot specialize functions that are created implicitly. */
1527 tree decl_arg_types;
1529 /* This is an ordinary member function. However, since
1530 we're here, we can assume it's enclosing class is a
1531 template class. For example,
1533 template <typename T> struct S { void f(); };
1534 template <> void S<int>::f() {}
1536 Here, S<int>::f is a non-template, but S<int> is a
1537 template class. If FN has the same type as DECL, we
1538 might be in business. */
1540 if (!DECL_TEMPLATE_INFO (fn))
1541 /* Its enclosing class is an explicit specialization
1542 of a template class. This is not a candidate. */
1545 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1546 TREE_TYPE (TREE_TYPE (fn))))
1547 /* The return types differ. */
1550 /* Adjust the type of DECL in case FN is a static member. */
1551 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1552 if (DECL_STATIC_FUNCTION_P (fn)
1553 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1554 decl_arg_types = TREE_CHAIN (decl_arg_types);
1556 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1559 candidates = tree_cons (NULL_TREE, fn, candidates);
1563 if (templates && TREE_CHAIN (templates))
1569 It is possible for a specialization with a given function
1570 signature to be instantiated from more than one function
1571 template. In such cases, explicit specification of the
1572 template arguments must be used to uniquely identify the
1573 function template specialization being specialized.
1575 Note that here, there's no suggestion that we're supposed to
1576 determine which of the candidate templates is most
1577 specialized. However, we, also have:
1581 Partial ordering of overloaded function template
1582 declarations is used in the following contexts to select
1583 the function template to which a function template
1584 specialization refers:
1586 -- when an explicit specialization refers to a function
1589 So, we do use the partial ordering rules, at least for now.
1590 This extension can only serve to make invalid programs valid,
1591 so it's safe. And, there is strong anecdotal evidence that
1592 the committee intended the partial ordering rules to apply;
1593 the EDG front-end has that behavior, and John Spicer claims
1594 that the committee simply forgot to delete the wording in
1595 [temp.expl.spec]. */
1596 tree tmpl = most_specialized_instantiation (templates);
1597 if (tmpl != error_mark_node)
1600 TREE_CHAIN (templates) = NULL_TREE;
1604 if (templates == NULL_TREE && candidates == NULL_TREE)
1606 error ("template-id %qD for %q+D does not match any template "
1607 "declaration", template_id, decl);
1608 return error_mark_node;
1610 else if ((templates && TREE_CHAIN (templates))
1611 || (candidates && TREE_CHAIN (candidates))
1612 || (templates && candidates))
1614 error ("ambiguous template specialization %qD for %q+D",
1616 chainon (candidates, templates);
1617 print_candidates (candidates);
1618 return error_mark_node;
1621 /* We have one, and exactly one, match. */
1624 tree fn = TREE_VALUE (candidates);
1625 /* DECL is a re-declaration of a template function. */
1626 if (TREE_CODE (fn) == TEMPLATE_DECL)
1628 /* It was a specialization of an ordinary member function in a
1630 *targs_out = copy_node (DECL_TI_ARGS (fn));
1631 return DECL_TI_TEMPLATE (fn);
1634 /* It was a specialization of a template. */
1635 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1636 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1638 *targs_out = copy_node (targs);
1639 SET_TMPL_ARGS_LEVEL (*targs_out,
1640 TMPL_ARGS_DEPTH (*targs_out),
1641 TREE_PURPOSE (templates));
1644 *targs_out = TREE_PURPOSE (templates);
1645 return TREE_VALUE (templates);
1648 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1649 but with the default argument values filled in from those in the
1653 copy_default_args_to_explicit_spec_1 (tree spec_types,
1656 tree new_spec_types;
1661 if (spec_types == void_list_node)
1662 return void_list_node;
1664 /* Substitute into the rest of the list. */
1666 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1667 TREE_CHAIN (tmpl_types));
1669 /* Add the default argument for this parameter. */
1670 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1671 TREE_VALUE (spec_types),
1675 /* DECL is an explicit specialization. Replicate default arguments
1676 from the template it specializes. (That way, code like:
1678 template <class T> void f(T = 3);
1679 template <> void f(double);
1682 works, as required.) An alternative approach would be to look up
1683 the correct default arguments at the call-site, but this approach
1684 is consistent with how implicit instantiations are handled. */
1687 copy_default_args_to_explicit_spec (tree decl)
1692 tree new_spec_types;
1696 tree object_type = NULL_TREE;
1697 tree in_charge = NULL_TREE;
1698 tree vtt = NULL_TREE;
1700 /* See if there's anything we need to do. */
1701 tmpl = DECL_TI_TEMPLATE (decl);
1702 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1703 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1704 if (TREE_PURPOSE (t))
1709 old_type = TREE_TYPE (decl);
1710 spec_types = TYPE_ARG_TYPES (old_type);
1712 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1714 /* Remove the this pointer, but remember the object's type for
1716 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1717 spec_types = TREE_CHAIN (spec_types);
1718 tmpl_types = TREE_CHAIN (tmpl_types);
1720 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1722 /* DECL may contain more parameters than TMPL due to the extra
1723 in-charge parameter in constructors and destructors. */
1724 in_charge = spec_types;
1725 spec_types = TREE_CHAIN (spec_types);
1727 if (DECL_HAS_VTT_PARM_P (decl))
1730 spec_types = TREE_CHAIN (spec_types);
1734 /* Compute the merged default arguments. */
1736 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1738 /* Compute the new FUNCTION_TYPE. */
1742 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1747 /* Put the in-charge parameter back. */
1748 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1749 TREE_VALUE (in_charge),
1752 new_type = build_method_type_directly (object_type,
1753 TREE_TYPE (old_type),
1757 new_type = build_function_type (TREE_TYPE (old_type),
1759 new_type = cp_build_type_attribute_variant (new_type,
1760 TYPE_ATTRIBUTES (old_type));
1761 new_type = build_exception_variant (new_type,
1762 TYPE_RAISES_EXCEPTIONS (old_type));
1763 TREE_TYPE (decl) = new_type;
1766 /* Check to see if the function just declared, as indicated in
1767 DECLARATOR, and in DECL, is a specialization of a function
1768 template. We may also discover that the declaration is an explicit
1769 instantiation at this point.
1771 Returns DECL, or an equivalent declaration that should be used
1772 instead if all goes well. Issues an error message if something is
1773 amiss. Returns error_mark_node if the error is not easily
1776 FLAGS is a bitmask consisting of the following flags:
1778 2: The function has a definition.
1779 4: The function is a friend.
1781 The TEMPLATE_COUNT is the number of references to qualifying
1782 template classes that appeared in the name of the function. For
1785 template <class T> struct S { void f(); };
1788 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1789 classes are not counted in the TEMPLATE_COUNT, so that in
1791 template <class T> struct S {};
1792 template <> struct S<int> { void f(); }
1793 template <> void S<int>::f();
1795 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1796 invalid; there should be no template <>.)
1798 If the function is a specialization, it is marked as such via
1799 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1800 is set up correctly, and it is added to the list of specializations
1801 for that template. */
1804 check_explicit_specialization (tree declarator,
1809 int have_def = flags & 2;
1810 int is_friend = flags & 4;
1811 int specialization = 0;
1812 int explicit_instantiation = 0;
1813 int member_specialization = 0;
1814 tree ctype = DECL_CLASS_CONTEXT (decl);
1815 tree dname = DECL_NAME (decl);
1820 if (!processing_specialization)
1823 tsk = tsk_excessive_parms;
1826 tsk = current_tmpl_spec_kind (template_count);
1831 if (processing_specialization)
1834 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1836 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1839 /* This could be something like:
1841 template <class T> void f(T);
1842 class S { friend void f<>(int); } */
1846 /* This case handles bogus declarations like template <>
1847 template <class T> void f<int>(); */
1849 error ("template-id %qD in declaration of primary template",
1856 case tsk_invalid_member_spec:
1857 /* The error has already been reported in
1858 check_specialization_scope. */
1859 return error_mark_node;
1861 case tsk_invalid_expl_inst:
1862 error ("template parameter list used in explicit instantiation");
1868 error ("definition provided for explicit instantiation");
1870 explicit_instantiation = 1;
1873 case tsk_excessive_parms:
1874 case tsk_insufficient_parms:
1875 if (tsk == tsk_excessive_parms)
1876 error ("too many template parameter lists in declaration of %qD",
1878 else if (template_header_count)
1879 error("too few template parameter lists in declaration of %qD", decl);
1881 error("explicit specialization of %qD must be introduced by "
1882 "%<template <>%>", decl);
1886 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1888 member_specialization = 1;
1894 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1896 /* This case handles bogus declarations like template <>
1897 template <class T> void f<int>(); */
1899 if (uses_template_parms (declarator))
1900 error ("function template partial specialization %qD "
1901 "is not allowed", declarator);
1903 error ("template-id %qD in declaration of primary template",
1908 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1909 /* This is a specialization of a member template, without
1910 specialization the containing class. Something like:
1912 template <class T> struct S {
1913 template <class U> void f (U);
1915 template <> template <class U> void S<int>::f(U) {}
1917 That's a specialization -- but of the entire template. */
1925 if (specialization || member_specialization)
1927 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1928 for (; t; t = TREE_CHAIN (t))
1929 if (TREE_PURPOSE (t))
1932 ("default argument specified in explicit specialization");
1937 if (specialization || member_specialization || explicit_instantiation)
1939 tree tmpl = NULL_TREE;
1940 tree targs = NULL_TREE;
1942 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1943 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1947 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
1952 /* If there is no class context, the explicit instantiation
1953 must be at namespace scope. */
1954 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
1956 /* Find the namespace binding, using the declaration
1958 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
1960 if (!fns || !is_overloaded_fn (fns))
1962 error ("%qD is not a template function", dname);
1963 fns = error_mark_node;
1967 tree fn = OVL_CURRENT (fns);
1968 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
1969 CP_DECL_CONTEXT (fn)))
1970 error ("%qD is not declared in %qD",
1971 decl, current_namespace);
1975 declarator = lookup_template_function (fns, NULL_TREE);
1978 if (declarator == error_mark_node)
1979 return error_mark_node;
1981 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1983 if (!explicit_instantiation)
1984 /* A specialization in class scope. This is invalid,
1985 but the error will already have been flagged by
1986 check_specialization_scope. */
1987 return error_mark_node;
1990 /* It's not valid to write an explicit instantiation in
1993 class C { template void f(); }
1995 This case is caught by the parser. However, on
1998 template class C { void f(); };
2000 (which is invalid) we can get here. The error will be
2007 else if (ctype != NULL_TREE
2008 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2011 /* Find the list of functions in ctype that have the same
2012 name as the declared function. */
2013 tree name = TREE_OPERAND (declarator, 0);
2014 tree fns = NULL_TREE;
2017 if (constructor_name_p (name, ctype))
2019 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2021 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
2022 : !CLASSTYPE_DESTRUCTORS (ctype))
2024 /* From [temp.expl.spec]:
2026 If such an explicit specialization for the member
2027 of a class template names an implicitly-declared
2028 special member function (clause _special_), the
2029 program is ill-formed.
2031 Similar language is found in [temp.explicit]. */
2032 error ("specialization of implicitly-declared special member function");
2033 return error_mark_node;
2036 name = is_constructor ? ctor_identifier : dtor_identifier;
2039 if (!DECL_CONV_FN_P (decl))
2041 idx = lookup_fnfields_1 (ctype, name);
2043 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2047 VEC(tree,gc) *methods;
2050 /* For a type-conversion operator, we cannot do a
2051 name-based lookup. We might be looking for `operator
2052 int' which will be a specialization of `operator T'.
2053 So, we find *all* the conversion operators, and then
2054 select from them. */
2057 methods = CLASSTYPE_METHOD_VEC (ctype);
2059 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2060 VEC_iterate (tree, methods, idx, ovl);
2063 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2064 /* There are no more conversion functions. */
2067 /* Glue all these conversion functions together
2068 with those we already have. */
2069 for (; ovl; ovl = OVL_NEXT (ovl))
2070 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2074 if (fns == NULL_TREE)
2076 error ("no member function %qD declared in %qT", name, ctype);
2077 return error_mark_node;
2080 TREE_OPERAND (declarator, 0) = fns;
2083 /* Figure out what exactly is being specialized at this point.
2084 Note that for an explicit instantiation, even one for a
2085 member function, we cannot tell apriori whether the
2086 instantiation is for a member template, or just a member
2087 function of a template class. Even if a member template is
2088 being instantiated, the member template arguments may be
2089 elided if they can be deduced from the rest of the
2091 tmpl = determine_specialization (declarator, decl,
2093 member_specialization,
2097 if (!tmpl || tmpl == error_mark_node)
2098 /* We couldn't figure out what this declaration was
2100 return error_mark_node;
2103 tree gen_tmpl = most_general_template (tmpl);
2105 if (explicit_instantiation)
2107 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2108 is done by do_decl_instantiation later. */
2110 int arg_depth = TMPL_ARGS_DEPTH (targs);
2111 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2113 if (arg_depth > parm_depth)
2115 /* If TMPL is not the most general template (for
2116 example, if TMPL is a friend template that is
2117 injected into namespace scope), then there will
2118 be too many levels of TARGS. Remove some of them
2123 new_targs = make_tree_vec (parm_depth);
2124 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2125 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2126 = TREE_VEC_ELT (targs, i);
2130 return instantiate_template (tmpl, targs, tf_error);
2133 /* If we thought that the DECL was a member function, but it
2134 turns out to be specializing a static member function,
2135 make DECL a static member function as well. */
2136 if (DECL_STATIC_FUNCTION_P (tmpl)
2137 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2138 revert_static_member_fn (decl);
2140 /* If this is a specialization of a member template of a
2141 template class, we want to return the TEMPLATE_DECL, not
2142 the specialization of it. */
2143 if (tsk == tsk_template)
2145 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2146 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2149 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2150 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2151 = DECL_SOURCE_LOCATION (decl);
2152 /* We want to use the argument list specified in the
2153 definition, not in the original declaration. */
2154 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2155 = DECL_ARGUMENTS (decl);
2160 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2161 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2163 /* Inherit default function arguments from the template
2164 DECL is specializing. */
2165 copy_default_args_to_explicit_spec (decl);
2167 /* This specialization has the same protection as the
2168 template it specializes. */
2169 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2170 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2172 /* If DECL is a friend declaration, declared using an
2173 unqualified name, the namespace associated with DECL may
2174 have been set incorrectly. For example, in:
2176 template <typename T> void f(T);
2178 struct S { friend void f<int>(int); }
2181 we will have set the DECL_CONTEXT for the friend
2182 declaration to N, rather than to the global namespace. */
2183 if (DECL_NAMESPACE_SCOPE_P (decl))
2184 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2186 if (is_friend && !have_def)
2187 /* This is not really a declaration of a specialization.
2188 It's just the name of an instantiation. But, it's not
2189 a request for an instantiation, either. */
2190 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2191 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2192 /* This is indeed a specialization. In case of constructors
2193 and destructors, we need in-charge and not-in-charge
2194 versions in V3 ABI. */
2195 clone_function_decl (decl, /*update_method_vec_p=*/0);
2197 /* Register this specialization so that we can find it
2199 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2206 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2207 parameters. These are represented in the same format used for
2208 DECL_TEMPLATE_PARMS. */
2211 comp_template_parms (tree parms1, tree parms2)
2216 if (parms1 == parms2)
2219 for (p1 = parms1, p2 = parms2;
2220 p1 != NULL_TREE && p2 != NULL_TREE;
2221 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2223 tree t1 = TREE_VALUE (p1);
2224 tree t2 = TREE_VALUE (p2);
2227 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2228 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2230 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2233 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2235 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2236 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2238 /* If either of the template parameters are invalid, assume
2239 they match for the sake of error recovery. */
2240 if (parm1 == error_mark_node || parm2 == error_mark_node)
2243 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2246 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2248 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2253 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2254 /* One set of parameters has more parameters lists than the
2261 /* Complain if DECL shadows a template parameter.
2263 [temp.local]: A template-parameter shall not be redeclared within its
2264 scope (including nested scopes). */
2267 check_template_shadow (tree decl)
2271 /* If we're not in a template, we can't possibly shadow a template
2273 if (!current_template_parms)
2276 /* Figure out what we're shadowing. */
2277 if (TREE_CODE (decl) == OVERLOAD)
2278 decl = OVL_CURRENT (decl);
2279 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2281 /* If there's no previous binding for this name, we're not shadowing
2282 anything, let alone a template parameter. */
2286 /* If we're not shadowing a template parameter, we're done. Note
2287 that OLDDECL might be an OVERLOAD (or perhaps even an
2288 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2290 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2293 /* We check for decl != olddecl to avoid bogus errors for using a
2294 name inside a class. We check TPFI to avoid duplicate errors for
2295 inline member templates. */
2297 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2300 error ("declaration of %q+#D", decl);
2301 error (" shadows template parm %q+#D", olddecl);
2304 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2305 ORIG_LEVEL, DECL, and TYPE. */
2308 build_template_parm_index (int index,
2314 tree t = make_node (TEMPLATE_PARM_INDEX);
2315 TEMPLATE_PARM_IDX (t) = index;
2316 TEMPLATE_PARM_LEVEL (t) = level;
2317 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2318 TEMPLATE_PARM_DECL (t) = decl;
2319 TREE_TYPE (t) = type;
2320 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2321 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2322 TREE_READONLY (t) = TREE_READONLY (decl);
2327 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2328 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2329 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2330 new one is created. */
2333 reduce_template_parm_level (tree index, tree type, int levels)
2335 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2336 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2337 != TEMPLATE_PARM_LEVEL (index) - levels))
2339 tree orig_decl = TEMPLATE_PARM_DECL (index);
2342 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2343 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2344 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2345 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2346 DECL_ARTIFICIAL (decl) = 1;
2347 SET_DECL_TEMPLATE_PARM_P (decl);
2349 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2350 TEMPLATE_PARM_LEVEL (index) - levels,
2351 TEMPLATE_PARM_ORIG_LEVEL (index),
2353 TEMPLATE_PARM_DESCENDANTS (index) = t;
2355 /* Template template parameters need this. */
2356 if (TREE_CODE (decl) != CONST_DECL)
2357 DECL_TEMPLATE_PARMS (decl)
2358 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2361 return TEMPLATE_PARM_DESCENDANTS (index);
2364 /* Process information from new template parameter PARM and append it to the
2365 LIST being built. This new parameter is a non-type parameter iff
2366 IS_NON_TYPE is true. */
2369 process_template_parm (tree list, tree parm, bool is_non_type)
2376 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2377 defval = TREE_PURPOSE (parm);
2381 tree p = tree_last (list);
2383 if (p && TREE_VALUE (p) != error_mark_node)
2386 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2387 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2389 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2399 parm = TREE_VALUE (parm);
2401 SET_DECL_TEMPLATE_PARM_P (parm);
2403 if (TREE_TYPE (parm) == error_mark_node)
2405 err_parm_list = build_tree_list (defval, parm);
2406 TREE_VALUE (err_parm_list) = error_mark_node;
2407 return chainon (list, err_parm_list);
2413 The top-level cv-qualifiers on the template-parameter are
2414 ignored when determining its type. */
2415 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2416 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2418 err_parm_list = build_tree_list (defval, parm);
2419 TREE_VALUE (err_parm_list) = error_mark_node;
2420 return chainon (list, err_parm_list);
2424 /* A template parameter is not modifiable. */
2425 TREE_CONSTANT (parm) = 1;
2426 TREE_INVARIANT (parm) = 1;
2427 TREE_READONLY (parm) = 1;
2428 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2429 TREE_CONSTANT (decl) = 1;
2430 TREE_INVARIANT (decl) = 1;
2431 TREE_READONLY (decl) = 1;
2432 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2433 = build_template_parm_index (idx, processing_template_decl,
2434 processing_template_decl,
2435 decl, TREE_TYPE (parm));
2440 parm = TREE_VALUE (TREE_VALUE (parm));
2442 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2444 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2445 /* This is for distinguishing between real templates and template
2446 template parameters */
2447 TREE_TYPE (parm) = t;
2448 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2453 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2454 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2455 decl = build_decl (TYPE_DECL, parm, t);
2458 TYPE_NAME (t) = decl;
2459 TYPE_STUB_DECL (t) = decl;
2461 TEMPLATE_TYPE_PARM_INDEX (t)
2462 = build_template_parm_index (idx, processing_template_decl,
2463 processing_template_decl,
2464 decl, TREE_TYPE (parm));
2466 DECL_ARTIFICIAL (decl) = 1;
2467 SET_DECL_TEMPLATE_PARM_P (decl);
2469 parm = build_tree_list (defval, parm);
2470 return chainon (list, parm);
2473 /* The end of a template parameter list has been reached. Process the
2474 tree list into a parameter vector, converting each parameter into a more
2475 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2479 end_template_parm_list (tree parms)
2483 tree saved_parmlist = make_tree_vec (list_length (parms));
2485 current_template_parms
2486 = tree_cons (size_int (processing_template_decl),
2487 saved_parmlist, current_template_parms);
2489 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2491 next = TREE_CHAIN (parm);
2492 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2493 TREE_CHAIN (parm) = NULL_TREE;
2496 --processing_template_parmlist;
2498 return saved_parmlist;
2501 /* end_template_decl is called after a template declaration is seen. */
2504 end_template_decl (void)
2506 reset_specialization ();
2508 if (! processing_template_decl)
2511 /* This matches the pushlevel in begin_template_parm_list. */
2514 --processing_template_decl;
2515 current_template_parms = TREE_CHAIN (current_template_parms);
2518 /* Given a template argument vector containing the template PARMS.
2519 The innermost PARMS are given first. */
2522 current_template_args (void)
2525 tree args = NULL_TREE;
2526 int length = TMPL_PARMS_DEPTH (current_template_parms);
2529 /* If there is only one level of template parameters, we do not
2530 create a TREE_VEC of TREE_VECs. Instead, we return a single
2531 TREE_VEC containing the arguments. */
2533 args = make_tree_vec (length);
2535 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2537 tree a = copy_node (TREE_VALUE (header));
2540 TREE_TYPE (a) = NULL_TREE;
2541 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2543 tree t = TREE_VEC_ELT (a, i);
2545 /* T will be a list if we are called from within a
2546 begin/end_template_parm_list pair, but a vector directly
2547 if within a begin/end_member_template_processing pair. */
2548 if (TREE_CODE (t) == TREE_LIST)
2552 if (t != error_mark_node)
2554 if (TREE_CODE (t) == TYPE_DECL
2555 || TREE_CODE (t) == TEMPLATE_DECL)
2558 t = DECL_INITIAL (t);
2561 TREE_VEC_ELT (a, i) = t;
2566 TREE_VEC_ELT (args, --l) = a;
2574 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2575 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
2576 a member template. Used by push_template_decl below. */
2579 build_template_decl (tree decl, tree parms, bool member_template_p)
2581 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2582 DECL_TEMPLATE_PARMS (tmpl) = parms;
2583 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2584 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
2585 if (DECL_LANG_SPECIFIC (decl))
2587 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2588 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2589 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2590 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2591 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2592 if (DECL_OVERLOADED_OPERATOR_P (decl))
2593 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2594 DECL_OVERLOADED_OPERATOR_P (decl));
2600 struct template_parm_data
2602 /* The level of the template parameters we are currently
2606 /* The index of the specialization argument we are currently
2610 /* An array whose size is the number of template parameters. The
2611 elements are nonzero if the parameter has been used in any one
2612 of the arguments processed so far. */
2615 /* An array whose size is the number of template arguments. The
2616 elements are nonzero if the argument makes use of template
2617 parameters of this level. */
2618 int* arg_uses_template_parms;
2621 /* Subroutine of push_template_decl used to see if each template
2622 parameter in a partial specialization is used in the explicit
2623 argument list. If T is of the LEVEL given in DATA (which is
2624 treated as a template_parm_data*), then DATA->PARMS is marked
2628 mark_template_parm (tree t, void* data)
2632 struct template_parm_data* tpd = (struct template_parm_data*) data;
2634 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2636 level = TEMPLATE_PARM_LEVEL (t);
2637 idx = TEMPLATE_PARM_IDX (t);
2641 level = TEMPLATE_TYPE_LEVEL (t);
2642 idx = TEMPLATE_TYPE_IDX (t);
2645 if (level == tpd->level)
2647 tpd->parms[idx] = 1;
2648 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2651 /* Return zero so that for_each_template_parm will continue the
2652 traversal of the tree; we want to mark *every* template parm. */
2656 /* Process the partial specialization DECL. */
2659 process_partial_specialization (tree decl)
2661 tree type = TREE_TYPE (decl);
2662 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2663 tree specargs = CLASSTYPE_TI_ARGS (type);
2664 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2665 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2666 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2667 int nargs = TREE_VEC_LENGTH (inner_args);
2668 int ntparms = TREE_VEC_LENGTH (inner_parms);
2670 int did_error_intro = 0;
2671 struct template_parm_data tpd;
2672 struct template_parm_data tpd2;
2674 /* We check that each of the template parameters given in the
2675 partial specialization is used in the argument list to the
2676 specialization. For example:
2678 template <class T> struct S;
2679 template <class T> struct S<T*>;
2681 The second declaration is OK because `T*' uses the template
2682 parameter T, whereas
2684 template <class T> struct S<int>;
2686 is no good. Even trickier is:
2697 The S2<T> declaration is actually invalid; it is a
2698 full-specialization. Of course,
2701 struct S2<T (*)(U)>;
2703 or some such would have been OK. */
2704 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2705 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
2706 memset (tpd.parms, 0, sizeof (int) * ntparms);
2708 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
2709 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2710 for (i = 0; i < nargs; ++i)
2712 tpd.current_arg = i;
2713 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2714 &mark_template_parm,
2718 for (i = 0; i < ntparms; ++i)
2719 if (tpd.parms[i] == 0)
2721 /* One of the template parms was not used in the
2723 if (!did_error_intro)
2725 error ("template parameters not used in partial specialization:");
2726 did_error_intro = 1;
2729 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2732 /* [temp.class.spec]
2734 The argument list of the specialization shall not be identical to
2735 the implicit argument list of the primary template. */
2736 if (comp_template_args
2738 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2740 error ("partial specialization %qT does not specialize any template arguments", type);
2742 /* [temp.class.spec]
2744 A partially specialized non-type argument expression shall not
2745 involve template parameters of the partial specialization except
2746 when the argument expression is a simple identifier.
2748 The type of a template parameter corresponding to a specialized
2749 non-type argument shall not be dependent on a parameter of the
2751 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
2753 for (i = 0; i < nargs; ++i)
2755 tree arg = TREE_VEC_ELT (inner_args, i);
2756 if (/* These first two lines are the `non-type' bit. */
2758 && TREE_CODE (arg) != TEMPLATE_DECL
2759 /* This next line is the `argument expression is not just a
2760 simple identifier' condition and also the `specialized
2761 non-type argument' bit. */
2762 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2764 if (tpd.arg_uses_template_parms[i])
2765 error ("template argument %qE involves template parameter(s)", arg);
2768 /* Look at the corresponding template parameter,
2769 marking which template parameters its type depends
2772 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2777 /* We haven't yet initialized TPD2. Do so now. */
2778 tpd2.arg_uses_template_parms
2779 = (int *) alloca (sizeof (int) * nargs);
2780 /* The number of parameters here is the number in the
2781 main template, which, as checked in the assertion
2783 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
2785 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2788 /* Mark the template parameters. But this time, we're
2789 looking for the template parameters of the main
2790 template, not in the specialization. */
2791 tpd2.current_arg = i;
2792 tpd2.arg_uses_template_parms[i] = 0;
2793 memset (tpd2.parms, 0, sizeof (int) * nargs);
2794 for_each_template_parm (type,
2795 &mark_template_parm,
2799 if (tpd2.arg_uses_template_parms [i])
2801 /* The type depended on some template parameters.
2802 If they are fully specialized in the
2803 specialization, that's OK. */
2805 for (j = 0; j < nargs; ++j)
2806 if (tpd2.parms[j] != 0
2807 && tpd.arg_uses_template_parms [j])
2809 error ("type %qT of template argument %qE depends "
2810 "on template parameter(s)",
2820 if (retrieve_specialization (maintmpl, specargs,
2821 /*class_specializations_p=*/true))
2822 /* We've already got this specialization. */
2825 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2826 = tree_cons (specargs, inner_parms,
2827 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2828 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2832 /* Check that a template declaration's use of default arguments is not
2833 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2834 nonzero if DECL is the thing declared by a primary template.
2835 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2838 check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2841 int last_level_to_check;
2846 A default template-argument shall not be specified in a
2847 function template declaration or a function template definition, nor
2848 in the template-parameter-list of the definition of a member of a
2851 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2852 /* You can't have a function template declaration in a local
2853 scope, nor you can you define a member of a class template in a
2857 if (current_class_type
2858 && !TYPE_BEING_DEFINED (current_class_type)
2859 && DECL_LANG_SPECIFIC (decl)
2860 /* If this is either a friend defined in the scope of the class
2861 or a member function. */
2862 && (DECL_FUNCTION_MEMBER_P (decl)
2863 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2864 : DECL_FRIEND_CONTEXT (decl)
2865 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2867 /* And, if it was a member function, it really was defined in
2868 the scope of the class. */
2869 && (!DECL_FUNCTION_MEMBER_P (decl)
2870 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2871 /* We already checked these parameters when the template was
2872 declared, so there's no need to do it again now. This function
2873 was defined in class scope, but we're processing it's body now
2874 that the class is complete. */
2879 If a template-parameter has a default template-argument, all
2880 subsequent template-parameters shall have a default
2881 template-argument supplied. */
2882 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2884 tree inner_parms = TREE_VALUE (parm_level);
2885 int ntparms = TREE_VEC_LENGTH (inner_parms);
2886 int seen_def_arg_p = 0;
2889 for (i = 0; i < ntparms; ++i)
2891 tree parm = TREE_VEC_ELT (inner_parms, i);
2893 if (parm == error_mark_node)
2896 if (TREE_PURPOSE (parm))
2898 else if (seen_def_arg_p)
2900 error ("no default argument for %qD", TREE_VALUE (parm));
2901 /* For better subsequent error-recovery, we indicate that
2902 there should have been a default argument. */
2903 TREE_PURPOSE (parm) = error_mark_node;
2908 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2909 /* For an ordinary class template, default template arguments are
2910 allowed at the innermost level, e.g.:
2911 template <class T = int>
2913 but, in a partial specialization, they're not allowed even
2914 there, as we have in [temp.class.spec]:
2916 The template parameter list of a specialization shall not
2917 contain default template argument values.
2919 So, for a partial specialization, or for a function template,
2920 we look at all of them. */
2923 /* But, for a primary class template that is not a partial
2924 specialization we look at all template parameters except the
2926 parms = TREE_CHAIN (parms);
2928 /* Figure out what error message to issue. */
2929 if (TREE_CODE (decl) == FUNCTION_DECL)
2930 msg = "default template arguments may not be used in function templates";
2931 else if (is_partial)
2932 msg = "default template arguments may not be used in partial specializations";
2934 msg = "default argument for template parameter for class enclosing %qD";
2936 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2937 /* If we're inside a class definition, there's no need to
2938 examine the parameters to the class itself. On the one
2939 hand, they will be checked when the class is defined, and,
2940 on the other, default arguments are valid in things like:
2941 template <class T = double>
2942 struct S { template <class U> void f(U); };
2943 Here the default argument for `S' has no bearing on the
2944 declaration of `f'. */
2945 last_level_to_check = template_class_depth (current_class_type) + 1;
2947 /* Check everything. */
2948 last_level_to_check = 0;
2950 for (parm_level = parms;
2951 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2952 parm_level = TREE_CHAIN (parm_level))
2954 tree inner_parms = TREE_VALUE (parm_level);
2958 ntparms = TREE_VEC_LENGTH (inner_parms);
2959 for (i = 0; i < ntparms; ++i)
2961 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
2964 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2972 /* Clear out the default argument so that we are not
2974 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2978 /* At this point, if we're still interested in issuing messages,
2979 they must apply to classes surrounding the object declared. */
2981 msg = "default argument for template parameter for class enclosing %qD";
2985 /* Worker for push_template_decl_real, called via
2986 for_each_template_parm. DATA is really an int, indicating the
2987 level of the parameters we are interested in. If T is a template
2988 parameter of that level, return nonzero. */
2991 template_parm_this_level_p (tree t, void* data)
2993 int this_level = *(int *)data;
2996 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2997 level = TEMPLATE_PARM_LEVEL (t);
2999 level = TEMPLATE_TYPE_LEVEL (t);
3000 return level == this_level;
3003 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3004 parameters given by current_template_args, or reuses a
3005 previously existing one, if appropriate. Returns the DECL, or an
3006 equivalent one, if it is replaced via a call to duplicate_decls.
3008 If IS_FRIEND is true, DECL is a friend declaration. */
3011 push_template_decl_real (tree decl, bool is_friend)
3019 int new_template_p = 0;
3020 /* True if the template is a member template, in the sense of
3022 bool member_template_p = false;
3024 if (decl == error_mark_node)
3027 /* See if this is a partial specialization. */
3028 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3029 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3030 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3032 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3036 /* For a friend, we want the context of the friend function, not
3037 the type of which it is a friend. */
3038 ctx = DECL_CONTEXT (decl);
3039 else if (CP_DECL_CONTEXT (decl)
3040 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3041 /* In the case of a virtual function, we want the class in which
3043 ctx = CP_DECL_CONTEXT (decl);
3045 /* Otherwise, if we're currently defining some class, the DECL
3046 is assumed to be a member of the class. */
3047 ctx = current_scope ();
3049 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3052 if (!DECL_CONTEXT (decl))
3053 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3055 /* See if this is a primary template. */
3056 if (is_friend && ctx)
3057 /* A friend template that specifies a class context, i.e.
3058 template <typename T> friend void A<T>::f();
3062 primary = template_parm_scope_p ();
3066 if (DECL_CLASS_SCOPE_P (decl))
3067 member_template_p = true;
3068 if (TREE_CODE (decl) == TYPE_DECL
3069 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3070 error ("template class without a name");
3071 else if (TREE_CODE (decl) == FUNCTION_DECL)
3073 if (DECL_DESTRUCTOR_P (decl))
3077 A destructor shall not be a member template. */
3078 error ("destructor %qD declared as member template", decl);
3079 return error_mark_node;
3081 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3082 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3083 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3084 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3085 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3086 == void_list_node)))
3088 /* [basic.stc.dynamic.allocation]
3090 An allocation function can be a function
3091 template. ... Template allocation functions shall
3092 have two or more parameters. */
3093 error ("invalid template declaration of %qD", decl);
3094 return error_mark_node;
3097 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3098 && CLASS_TYPE_P (TREE_TYPE (decl)))
3102 error ("template declaration of %q#D", decl);
3103 return error_mark_node;
3107 /* Check to see that the rules regarding the use of default
3108 arguments are not being violated. */
3109 check_default_tmpl_args (decl, current_template_parms,
3110 primary, is_partial);
3113 return process_partial_specialization (decl);
3115 args = current_template_args ();
3118 || TREE_CODE (ctx) == FUNCTION_DECL
3119 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3120 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3122 if (DECL_LANG_SPECIFIC (decl)
3123 && DECL_TEMPLATE_INFO (decl)
3124 && DECL_TI_TEMPLATE (decl))
3125 tmpl = DECL_TI_TEMPLATE (decl);
3126 /* If DECL is a TYPE_DECL for a class-template, then there won't
3127 be DECL_LANG_SPECIFIC. The information equivalent to
3128 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3129 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3130 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3131 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3133 /* Since a template declaration already existed for this
3134 class-type, we must be redeclaring it here. Make sure
3135 that the redeclaration is valid. */
3136 redeclare_class_template (TREE_TYPE (decl),
3137 current_template_parms);
3138 /* We don't need to create a new TEMPLATE_DECL; just use the
3139 one we already had. */
3140 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3144 tmpl = build_template_decl (decl, current_template_parms,
3148 if (DECL_LANG_SPECIFIC (decl)
3149 && DECL_TEMPLATE_SPECIALIZATION (decl))
3151 /* A specialization of a member template of a template
3153 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3154 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3155 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3161 tree a, t, current, parms;
3164 if (TREE_CODE (decl) == TYPE_DECL)
3166 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
3167 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
3168 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3169 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3170 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3173 error ("%qD does not declare a template type", decl);
3177 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
3179 error ("template definition of non-template %q#D", decl);
3183 tmpl = DECL_TI_TEMPLATE (decl);
3185 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3186 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3187 && DECL_TEMPLATE_SPECIALIZATION (decl)
3188 && DECL_MEMBER_TEMPLATE_P (tmpl))
3192 /* The declaration is a specialization of a member
3193 template, declared outside the class. Therefore, the
3194 innermost template arguments will be NULL, so we
3195 replace them with the arguments determined by the
3196 earlier call to check_explicit_specialization. */
3197 args = DECL_TI_ARGS (decl);
3200 = build_template_decl (decl, current_template_parms,
3202 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3203 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3204 DECL_TI_TEMPLATE (decl) = new_tmpl;
3205 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3206 DECL_TEMPLATE_INFO (new_tmpl)
3207 = tree_cons (tmpl, args, NULL_TREE);
3209 register_specialization (new_tmpl,
3210 most_general_template (tmpl),
3216 /* Make sure the template headers we got make sense. */
3218 parms = DECL_TEMPLATE_PARMS (tmpl);
3219 i = TMPL_PARMS_DEPTH (parms);
3220 if (TMPL_ARGS_DEPTH (args) != i)
3222 error ("expected %d levels of template parms for %q#D, got %d",
3223 i, decl, TMPL_ARGS_DEPTH (args));
3226 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3228 a = TMPL_ARGS_LEVEL (args, i);
3229 t = INNERMOST_TEMPLATE_PARMS (parms);
3231 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3233 if (current == decl)
3234 error ("got %d template parameters for %q#D",
3235 TREE_VEC_LENGTH (a), decl);
3237 error ("got %d template parameters for %q#T",
3238 TREE_VEC_LENGTH (a), current);
3239 error (" but %d required", TREE_VEC_LENGTH (t));
3240 return error_mark_node;
3243 /* Perhaps we should also check that the parms are used in the
3244 appropriate qualifying scopes in the declarator? */
3246 if (current == decl)
3249 current = TYPE_CONTEXT (current);
3253 DECL_TEMPLATE_RESULT (tmpl) = decl;
3254 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3256 /* Push template declarations for global functions and types. Note
3257 that we do not try to push a global template friend declared in a
3258 template class; such a thing may well depend on the template
3259 parameters of the class. */
3260 if (new_template_p && !ctx
3261 && !(is_friend && template_class_depth (current_class_type) > 0))
3263 tmpl = pushdecl_namespace_level (tmpl, is_friend);
3264 if (tmpl == error_mark_node)
3265 return error_mark_node;
3267 /* Hide template friend classes that haven't been declared yet. */
3268 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
3270 DECL_ANTICIPATED (tmpl) = 1;
3271 DECL_FRIEND_P (tmpl) = 1;
3277 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3278 if (DECL_CONV_FN_P (tmpl))
3280 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3282 /* It is a conversion operator. See if the type converted to
3283 depends on innermost template operands. */
3285 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3287 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3291 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3292 back to its most general template. If TMPL is a specialization,
3293 ARGS may only have the innermost set of arguments. Add the missing
3294 argument levels if necessary. */
3295 if (DECL_TEMPLATE_INFO (tmpl))
3296 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3298 info = tree_cons (tmpl, args, NULL_TREE);
3300 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3302 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3303 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
3304 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3305 /* Don't change the name if we've already set it up. */
3306 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
3307 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
3309 else if (DECL_LANG_SPECIFIC (decl))
3310 DECL_TEMPLATE_INFO (decl) = info;
3312 return DECL_TEMPLATE_RESULT (tmpl);
3316 push_template_decl (tree decl)
3318 return push_template_decl_real (decl, false);
3321 /* Called when a class template TYPE is redeclared with the indicated
3322 template PARMS, e.g.:
3324 template <class T> struct S;
3325 template <class T> struct S {}; */
3328 redeclare_class_template (tree type, tree parms)
3334 if (!TYPE_TEMPLATE_INFO (type))
3336 error ("%qT is not a template type", type);
3340 tmpl = TYPE_TI_TEMPLATE (type);
3341 if (!PRIMARY_TEMPLATE_P (tmpl))
3342 /* The type is nested in some template class. Nothing to worry
3343 about here; there are no new template parameters for the nested
3349 error ("template specifiers not specified in declaration of %qD",
3354 parms = INNERMOST_TEMPLATE_PARMS (parms);
3355 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3357 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3359 error ("previous declaration %q+D", tmpl);
3360 error ("used %d template parameter(s) instead of %d",
3361 TREE_VEC_LENGTH (tmpl_parms),
3362 TREE_VEC_LENGTH (parms));
3366 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3373 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
3374 || TREE_VEC_ELT (parms, i) == error_mark_node)
3377 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3378 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3379 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3380 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3382 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
3384 if (tmpl_parm != error_mark_node
3385 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
3386 || (TREE_CODE (tmpl_parm) != TYPE_DECL
3387 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
3389 error ("template parameter %q+#D", tmpl_parm);
3390 error ("redeclared here as %q#D", parm);
3394 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3396 /* We have in [temp.param]:
3398 A template-parameter may not be given default arguments
3399 by two different declarations in the same scope. */
3400 error ("redefinition of default argument for %q#D", parm);
3401 error ("%J original definition appeared here", tmpl_parm);
3405 if (parm_default != NULL_TREE)
3406 /* Update the previous template parameters (which are the ones
3407 that will really count) with the new default value. */
3408 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3409 else if (tmpl_default != NULL_TREE)
3410 /* Update the new parameters, too; they'll be used as the
3411 parameters for any members. */
3412 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3418 /* Simplify EXPR if it is a non-dependent expression. Returns the
3419 (possibly simplified) expression. */
3422 fold_non_dependent_expr (tree expr)
3424 if (expr == NULL_TREE)
3427 /* If we're in a template, but EXPR isn't value dependent, simplify
3428 it. We're supposed to treat:
3430 template <typename T> void f(T[1 + 1]);
3431 template <typename T> void f(T[2]);
3433 as two declarations of the same function, for example. */
3434 if (processing_template_decl
3435 && !type_dependent_expression_p (expr)
3436 && !value_dependent_expression_p (expr))
3438 HOST_WIDE_INT saved_processing_template_decl;
3440 saved_processing_template_decl = processing_template_decl;
3441 processing_template_decl = 0;
3442 expr = tsubst_copy_and_build (expr,
3445 /*in_decl=*/NULL_TREE,
3446 /*function_p=*/false,
3447 /*integral_constant_expression_p=*/true);
3448 processing_template_decl = saved_processing_template_decl;
3453 /* EXPR is an expression which is used in a constant-expression context.
3454 For instance, it could be a VAR_DECL with a constant initializer.
3455 Extract the innest constant expression.
3457 This is basically a more powerful version of
3458 integral_constant_value, which can be used also in templates where
3459 initializers can maintain a syntactic rather than semantic form
3460 (even if they are non-dependent, for access-checking purposes). */
3463 fold_decl_constant_value (tree expr)
3465 tree const_expr = expr;
3468 expr = fold_non_dependent_expr (const_expr);
3469 const_expr = integral_constant_value (expr);
3471 while (expr != const_expr);
3476 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
3477 must be a function or a pointer-to-function type, as specified
3478 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
3479 and check that the resulting function has external linkage. */
3482 convert_nontype_argument_function (tree type, tree expr)
3487 fn = instantiate_type (type, fns, tf_none);
3488 if (fn == error_mark_node)
3489 return error_mark_node;
3492 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
3493 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
3494 if (TREE_CODE (fn_no_ptr) == BASELINK)
3495 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
3497 /* [temp.arg.nontype]/1
3499 A template-argument for a non-type, non-template template-parameter
3502 -- the address of an object or function with external linkage. */
3503 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
3505 error ("%qE is not a valid template argument for type %qT "
3506 "because function %qD has not external linkage",
3507 expr, type, fn_no_ptr);
3514 /* Attempt to convert the non-type template parameter EXPR to the
3515 indicated TYPE. If the conversion is successful, return the
3516 converted value. If the conversion is unsuccessful, return
3517 NULL_TREE if we issued an error message, or error_mark_node if we
3518 did not. We issue error messages for out-and-out bad template
3519 parameters, but not simply because the conversion failed, since we
3520 might be just trying to do argument deduction. Both TYPE and EXPR
3521 must be non-dependent.
3523 The conversion follows the special rules described in
3524 [temp.arg.nontype], and it is much more strict than an implicit
3527 This function is called twice for each template argument (see
3528 lookup_template_class for a more accurate description of this
3529 problem). This means that we need to handle expressions which
3530 are not valid in a C++ source, but can be created from the
3531 first call (for instance, casts to perform conversions). These
3532 hacks can go away after we fix the double coercion problem. */
3535 convert_nontype_argument (tree type, tree expr)
3539 /* Detect immediately string literals as invalid non-type argument.
3540 This special-case is not needed for correctness (we would easily
3541 catch this later), but only to provide better diagnostic for this
3542 common user mistake. As suggested by DR 100, we do not mention
3543 linkage issues in the diagnostic as this is not the point. */
3544 if (TREE_CODE (expr) == STRING_CST)
3546 error ("%qE is not a valid template argument for type %qT "
3547 "because string literals can never be used in this context",
3552 /* If we are in a template, EXPR may be non-dependent, but still
3553 have a syntactic, rather than semantic, form. For example, EXPR
3554 might be a SCOPE_REF, rather than the VAR_DECL to which the
3555 SCOPE_REF refers. Preserving the qualifying scope is necessary
3556 so that access checking can be performed when the template is
3557 instantiated -- but here we need the resolved form so that we can
3558 convert the argument. */
3559 expr = fold_non_dependent_expr (expr);
3560 if (error_operand_p (expr))
3561 return error_mark_node;
3562 expr_type = TREE_TYPE (expr);
3564 /* HACK: Due to double coercion, we can get a
3565 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
3566 which is the tree that we built on the first call (see
3567 below when coercing to reference to object or to reference to
3568 function). We just strip everything and get to the arg.
3569 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
3571 if (TREE_CODE (expr) == NOP_EXPR)
3573 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
3575 /* ??? Maybe we could use convert_from_reference here, but we
3576 would need to relax its constraints because the NOP_EXPR
3577 could actually change the type to something more cv-qualified,
3578 and this is not folded by convert_from_reference. */
3579 tree addr = TREE_OPERAND (expr, 0);
3580 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
3581 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
3582 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
3583 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3584 (TREE_TYPE (expr_type),
3585 TREE_TYPE (TREE_TYPE (addr))));
3587 expr = TREE_OPERAND (addr, 0);
3588 expr_type = TREE_TYPE (expr);
3591 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
3592 parameter is a pointer to object, through decay and
3593 qualification conversion. Let's strip everything. */
3594 else if (TYPE_PTROBV_P (type))
3597 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
3598 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
3599 /* Skip the ADDR_EXPR only if it is part of the decay for
3600 an array. Otherwise, it is part of the original argument
3601 in the source code. */
3602 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
3603 expr = TREE_OPERAND (expr, 0);
3604 expr_type = TREE_TYPE (expr);
3608 /* [temp.arg.nontype]/5, bullet 1
3610 For a non-type template-parameter of integral or enumeration type,
3611 integral promotions (_conv.prom_) and integral conversions
3612 (_conv.integral_) are applied. */
3613 if (INTEGRAL_TYPE_P (type))
3615 if (!INTEGRAL_TYPE_P (expr_type))
3616 return error_mark_node;
3618 expr = fold_decl_constant_value (expr);
3619 /* Notice that there are constant expressions like '4 % 0' which
3620 do not fold into integer constants. */
3621 if (TREE_CODE (expr) != INTEGER_CST)
3623 error ("%qE is not a valid template argument for type %qT "
3624 "because it is a non-constant expression", expr, type);
3628 /* At this point, an implicit conversion does what we want,
3629 because we already know that the expression is of integral
3631 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
3632 if (expr == error_mark_node)
3633 return error_mark_node;
3635 /* Conversion was allowed: fold it to a bare integer constant. */
3638 /* [temp.arg.nontype]/5, bullet 2
3640 For a non-type template-parameter of type pointer to object,
3641 qualification conversions (_conv.qual_) and the array-to-pointer
3642 conversion (_conv.array_) are applied. */
3643 else if (TYPE_PTROBV_P (type))
3645 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
3647 A template-argument for a non-type, non-template template-parameter
3648 shall be one of: [...]
3650 -- the name of a non-type template-parameter;
3651 -- the address of an object or function with external linkage, [...]
3652 expressed as "& id-expression" where the & is optional if the name
3653 refers to a function or array, or if the corresponding
3654 template-parameter is a reference.
3656 Here, we do not care about functions, as they are invalid anyway
3657 for a parameter of type pointer-to-object. */
3659 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
3660 /* Non-type template parameters are OK. */
3662 else if (TREE_CODE (expr) != ADDR_EXPR
3663 && TREE_CODE (expr_type) != ARRAY_TYPE)
3665 if (TREE_CODE (expr) == VAR_DECL)
3667 error ("%qD is not a valid template argument "
3668 "because %qD is a variable, not the address of "
3673 /* Other values, like integer constants, might be valid
3674 non-type arguments of some other type. */
3675 return error_mark_node;
3681 decl = ((TREE_CODE (expr) == ADDR_EXPR)
3682 ? TREE_OPERAND (expr, 0) : expr);
3683 if (TREE_CODE (decl) != VAR_DECL)
3685 error ("%qE is not a valid template argument of type %qT "
3686 "because %qE is not a variable",
3690 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
3692 error ("%qE is not a valid template argument of type %qT "
3693 "because %qD does not have external linkage",
3699 expr = decay_conversion (expr);
3700 if (expr == error_mark_node)
3701 return error_mark_node;
3703 expr = perform_qualification_conversions (type, expr);
3704 if (expr == error_mark_node)
3705 return error_mark_node;
3707 /* [temp.arg.nontype]/5, bullet 3
3709 For a non-type template-parameter of type reference to object, no
3710 conversions apply. The type referred to by the reference may be more
3711 cv-qualified than the (otherwise identical) type of the
3712 template-argument. The template-parameter is bound directly to the
3713 template-argument, which must be an lvalue. */
3714 else if (TYPE_REF_OBJ_P (type))
3716 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
3718 return error_mark_node;
3720 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
3722 error ("%qE is not a valid template argument for type %qT "
3723 "because of conflicts in cv-qualification", expr, type);
3727 if (!real_lvalue_p (expr))
3729 error ("%qE is not a valid template argument for type %qT "
3730 "because it is not an lvalue", expr, type);
3734 /* [temp.arg.nontype]/1
3736 A template-argument for a non-type, non-template template-parameter
3737 shall be one of: [...]
3739 -- the address of an object or function with external linkage. */
3740 if (!DECL_EXTERNAL_LINKAGE_P (expr))
3742 error ("%qE is not a valid template argument for type %qT "
3743 "because object %qD has not external linkage",
3748 expr = build_nop (type, build_address (expr));
3750 /* [temp.arg.nontype]/5, bullet 4
3752 For a non-type template-parameter of type pointer to function, only
3753 the function-to-pointer conversion (_conv.func_) is applied. If the
3754 template-argument represents a set of overloaded functions (or a
3755 pointer to such), the matching function is selected from the set
3757 else if (TYPE_PTRFN_P (type))
3759 /* If the argument is a template-id, we might not have enough
3760 context information to decay the pointer. */
3761 if (!type_unknown_p (expr_type))
3763 expr = decay_conversion (expr);
3764 if (expr == error_mark_node)
3765 return error_mark_node;
3768 expr = convert_nontype_argument_function (type, expr);
3769 if (!expr || expr == error_mark_node)
3772 /* [temp.arg.nontype]/5, bullet 5
3774 For a non-type template-parameter of type reference to function, no
3775 conversions apply. If the template-argument represents a set of
3776 overloaded functions, the matching function is selected from the set
3778 else if (TYPE_REFFN_P (type))
3780 if (TREE_CODE (expr) == ADDR_EXPR)
3782 error ("%qE is not a valid template argument for type %qT "
3783 "because it is a pointer", expr, type);
3784 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
3788 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
3789 if (!expr || expr == error_mark_node)
3792 expr = build_nop (type, build_address (expr));
3794 /* [temp.arg.nontype]/5, bullet 6
3796 For a non-type template-parameter of type pointer to member function,
3797 no conversions apply. If the template-argument represents a set of
3798 overloaded member functions, the matching member function is selected
3799 from the set (_over.over_). */
3800 else if (TYPE_PTRMEMFUNC_P (type))
3802 expr = instantiate_type (type, expr, tf_none);
3803 if (expr == error_mark_node)
3804 return error_mark_node;
3806 /* There is no way to disable standard conversions in
3807 resolve_address_of_overloaded_function (called by
3808 instantiate_type). It is possible that the call succeeded by
3809 converting &B::I to &D::I (where B is a base of D), so we need
3810 to reject this conversion here.
3812 Actually, even if there was a way to disable standard conversions,
3813 it would still be better to reject them here so that we can
3814 provide a superior diagnostic. */
3815 if (!same_type_p (TREE_TYPE (expr), type))
3817 /* Make sure we are just one standard conversion off. */
3818 gcc_assert (can_convert (type, TREE_TYPE (expr)));
3819 error ("%qE is not a valid template argument for type %qT "
3820 "because it is of type %qT", expr, type,
3822 inform ("standard conversions are not allowed in this context");
3826 /* [temp.arg.nontype]/5, bullet 7
3828 For a non-type template-parameter of type pointer to data member,
3829 qualification conversions (_conv.qual_) are applied. */
3830 else if (TYPE_PTRMEM_P (type))
3832 expr = perform_qualification_conversions (type, expr);
3833 if (expr == error_mark_node)
3836 /* A template non-type parameter must be one of the above. */
3840 /* Sanity check: did we actually convert the argument to the
3842 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
3847 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3848 template template parameters. Both PARM_PARMS and ARG_PARMS are
3849 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3852 Consider the example:
3853 template <class T> class A;
3854 template<template <class U> class TT> class B;
3856 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
3857 the parameters to A, and OUTER_ARGS contains A. */
3860 coerce_template_template_parms (tree parm_parms,
3862 tsubst_flags_t complain,
3866 int nparms, nargs, i;
3869 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
3870 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
3872 nparms = TREE_VEC_LENGTH (parm_parms);
3873 nargs = TREE_VEC_LENGTH (arg_parms);
3875 if (nargs != nparms)
3878 for (i = 0; i < nparms; ++i)
3880 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
3881 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
3884 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3885 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3887 if (arg == NULL_TREE || arg == error_mark_node
3888 || parm == NULL_TREE || parm == error_mark_node)
3891 if (TREE_CODE (arg) != TREE_CODE (parm))
3894 switch (TREE_CODE (parm))
3900 /* We encounter instantiations of templates like
3901 template <template <template <class> class> class TT>
3904 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3905 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3907 if (!coerce_template_template_parms
3908 (parmparm, argparm, complain, in_decl, outer_args))
3914 /* The tsubst call is used to handle cases such as
3916 template <int> class C {};
3917 template <class T, template <T> class TT> class D {};
3920 i.e. the parameter list of TT depends on earlier parameters. */
3921 if (!dependent_type_p (TREE_TYPE (arg))
3923 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3935 /* Convert the indicated template ARG as necessary to match the
3936 indicated template PARM. Returns the converted ARG, or
3937 error_mark_node if the conversion was unsuccessful. Error and
3938 warning messages are issued under control of COMPLAIN. This
3939 conversion is for the Ith parameter in the parameter list. ARGS is
3940 the full set of template arguments deduced so far. */
3943 convert_template_argument (tree parm,
3946 tsubst_flags_t complain,
3951 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3953 if (TREE_CODE (arg) == TREE_LIST
3954 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3956 /* The template argument was the name of some
3957 member function. That's usually
3958 invalid, but static members are OK. In any
3959 case, grab the underlying fields/functions
3960 and issue an error later if required. */
3961 arg = TREE_VALUE (arg);
3962 TREE_TYPE (arg) = unknown_type_node;
3965 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3966 requires_type = (TREE_CODE (parm) == TYPE_DECL
3967 || requires_tmpl_type);
3969 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3970 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3971 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3972 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3975 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3976 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3977 arg = TYPE_STUB_DECL (arg);
3979 is_type = TYPE_P (arg) || is_tmpl_type;
3981 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3982 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3984 pedwarn ("to refer to a type member of a template parameter, "
3985 "use %<typename %E%>", arg);
3987 arg = make_typename_type (TREE_OPERAND (arg, 0),
3988 TREE_OPERAND (arg, 1),
3990 complain & tf_error);
3993 if (is_type != requires_type)
3997 if (complain & tf_error)
3999 error ("type/value mismatch at argument %d in template "
4000 "parameter list for %qD",
4003 error (" expected a constant of type %qT, got %qT",
4005 (is_tmpl_type ? DECL_NAME (arg) : arg));
4006 else if (requires_tmpl_type)
4007 error (" expected a class template, got %qE", arg);
4009 error (" expected a type, got %qE", arg);
4012 return error_mark_node;
4014 if (is_tmpl_type ^ requires_tmpl_type)
4016 if (in_decl && (complain & tf_error))
4018 error ("type/value mismatch at argument %d in template "
4019 "parameter list for %qD",
4022 error (" expected a type, got %qT", DECL_NAME (arg));
4024 error (" expected a class template, got %qT", arg);
4026 return error_mark_node;
4031 if (requires_tmpl_type)
4033 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4034 /* The number of argument required is not known yet.
4035 Just accept it for now. */
4036 val = TREE_TYPE (arg);
4039 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4040 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4042 if (coerce_template_template_parms (parmparm, argparm,
4048 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4050 if (val != error_mark_node
4051 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4052 val = TREE_TYPE (val);
4056 if (in_decl && (complain & tf_error))
4058 error ("type/value mismatch at argument %d in "
4059 "template parameter list for %qD",
4061 error (" expected a template of type %qD, got %qD",
4065 val = error_mark_node;
4071 /* We only form one instance of each template specialization.
4072 Therefore, if we use a non-canonical variant (i.e., a
4073 typedef), any future messages referring to the type will use
4074 the typedef, which is confusing if those future uses do not
4075 themselves also use the typedef. */
4077 val = canonical_type_variant (val);
4081 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4083 if (invalid_nontype_parm_type_p (t, complain))
4084 return error_mark_node;
4086 if (!uses_template_parms (arg) && !uses_template_parms (t))
4087 /* We used to call digest_init here. However, digest_init
4088 will report errors, which we don't want when complain
4089 is zero. More importantly, digest_init will try too
4090 hard to convert things: for example, `0' should not be
4091 converted to pointer type at this point according to
4092 the standard. Accepting this is not merely an
4093 extension, since deciding whether or not these
4094 conversions can occur is part of determining which
4095 function template to call, or whether a given explicit
4096 argument specification is valid. */
4097 val = convert_nontype_argument (t, arg);
4101 if (val == NULL_TREE)
4102 val = error_mark_node;
4103 else if (val == error_mark_node && (complain & tf_error))
4104 error ("could not convert template argument %qE to %qT", arg, t);
4110 /* Convert all template arguments to their appropriate types, and
4111 return a vector containing the innermost resulting template
4112 arguments. If any error occurs, return error_mark_node. Error and
4113 warning messages are issued under control of COMPLAIN.
4115 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
4116 for arguments not specified in ARGS. Otherwise, if
4117 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
4118 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
4119 USE_DEFAULT_ARGS is false, then all arguments must be specified in
4123 coerce_template_parms (tree parms,
4126 tsubst_flags_t complain,
4127 bool require_all_args,
4128 bool use_default_args)
4130 int nparms, nargs, i, lost = 0;
4133 tree new_inner_args;
4134 bool saved_skip_evaluation;
4136 inner_args = INNERMOST_TEMPLATE_ARGS (args);
4137 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4138 nparms = TREE_VEC_LENGTH (parms);
4143 && (!use_default_args
4144 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
4145 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
4147 if (complain & tf_error)
4149 error ("wrong number of template arguments (%d, should be %d)",
4153 error ("provided for %q+D", in_decl);
4156 return error_mark_node;
4159 /* We need to evaluate the template arguments, even though this
4160 template-id may be nested within a "sizeof". */
4161 saved_skip_evaluation = skip_evaluation;
4162 skip_evaluation = false;
4163 new_inner_args = make_tree_vec (nparms);
4164 new_args = add_outermost_template_args (args, new_inner_args);
4165 for (i = 0; i < nparms; i++)
4170 /* Get the Ith template parameter. */
4171 parm = TREE_VEC_ELT (parms, i);
4173 if (parm == error_mark_node)
4175 TREE_VEC_ELT (new_inner_args, i) = error_mark_node;
4179 /* Calculate the Ith argument. */
4181 arg = TREE_VEC_ELT (inner_args, i);
4182 else if (require_all_args)
4183 /* There must be a default arg in this case. */
4184 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
4190 if (arg == error_mark_node)
4192 if (complain & tf_error)
4193 error ("template argument %d is invalid", i + 1);
4196 arg = convert_template_argument (TREE_VALUE (parm),
4197 arg, new_args, complain, i,
4200 if (arg == error_mark_node)
4202 TREE_VEC_ELT (new_inner_args, i) = arg;
4204 skip_evaluation = saved_skip_evaluation;
4207 return error_mark_node;
4209 return new_inner_args;
4212 /* Returns 1 if template args OT and NT are equivalent. */
4215 template_args_equal (tree ot, tree nt)
4220 if (TREE_CODE (nt) == TREE_VEC)
4221 /* For member templates */
4222 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
4223 else if (TYPE_P (nt))
4224 return TYPE_P (ot) && same_type_p (ot, nt);
4225 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
4228 return cp_tree_equal (ot, nt);
4231 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
4232 of template arguments. Returns 0 otherwise. */
4235 comp_template_args (tree oldargs, tree newargs)
4239 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
4242 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
4244 tree nt = TREE_VEC_ELT (newargs, i);
4245 tree ot = TREE_VEC_ELT (oldargs, i);
4247 if (! template_args_equal (ot, nt))
4253 /* Given class template name and parameter list, produce a user-friendly name
4254 for the instantiation. */
4257 mangle_class_name_for_template (const char* name, tree parms, tree arglist)
4259 static struct obstack scratch_obstack;
4260 static char *scratch_firstobj;
4263 if (!scratch_firstobj)
4264 gcc_obstack_init (&scratch_obstack);
4266 obstack_free (&scratch_obstack, scratch_firstobj);
4267 scratch_firstobj = (char *) obstack_alloc (&scratch_obstack, 1);
4269 #define ccat(C) obstack_1grow (&scratch_obstack, (C));
4270 #define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
4274 nparms = TREE_VEC_LENGTH (parms);
4275 arglist = INNERMOST_TEMPLATE_ARGS (arglist);
4276 gcc_assert (nparms == TREE_VEC_LENGTH (arglist));
4277 for (i = 0; i < nparms; i++)
4282 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4283 arg = TREE_VEC_ELT (arglist, i);
4285 if (parm == error_mark_node)
4291 if (TREE_CODE (parm) == TYPE_DECL)
4293 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4296 else if (TREE_CODE (parm) == TEMPLATE_DECL)
4298 if (TREE_CODE (arg) == TEMPLATE_DECL)
4300 /* Already substituted with real template. Just output
4301 the template name here */
4302 tree context = DECL_CONTEXT (arg);
4305 /* The template may be defined in a namespace, or
4306 may be a member template. */
4307 gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
4308 || CLASS_TYPE_P (context));
4309 cat (decl_as_string (DECL_CONTEXT (arg),
4310 TFF_PLAIN_IDENTIFIER));
4313 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
4316 /* Output the parameter declaration. */
4317 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4321 gcc_assert (TREE_CODE (parm) == PARM_DECL);
4323 /* No need to check arglist against parmlist here; we did that
4324 in coerce_template_parms, called from lookup_template_class. */
4325 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
4328 char *bufp = obstack_next_free (&scratch_obstack);
4330 while (bufp[offset - 1] == ' ')
4332 obstack_blank_fast (&scratch_obstack, offset);
4334 /* B<C<char> >, not B<C<char>> */
4335 if (bufp[offset - 1] == '>')
4340 return (char *) obstack_base (&scratch_obstack);
4344 classtype_mangled_name (tree t)
4346 if (CLASSTYPE_TEMPLATE_INFO (t)
4347 /* Specializations have already had their names set up in
4348 lookup_template_class. */
4349 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4351 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4353 /* For non-primary templates, the template parameters are
4354 implicit from their surrounding context. */
4355 if (PRIMARY_TEMPLATE_P (tmpl))
4357 tree name = DECL_NAME (tmpl);
4358 char *mangled_name = mangle_class_name_for_template
4359 (IDENTIFIER_POINTER (name),
4360 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4361 CLASSTYPE_TI_ARGS (t));
4362 tree id = get_identifier (mangled_name);
4363 IDENTIFIER_TEMPLATE (id) = name;
4368 return TYPE_IDENTIFIER (t);
4372 add_pending_template (tree d)
4374 tree ti = (TYPE_P (d)
4375 ? CLASSTYPE_TEMPLATE_INFO (d)
4376 : DECL_TEMPLATE_INFO (d));
4380 if (TI_PENDING_TEMPLATE_FLAG (ti))
4383 /* We are called both from instantiate_decl, where we've already had a
4384 tinst_level pushed, and instantiate_template, where we haven't.
4386 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4389 push_tinst_level (d);
4391 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4392 if (last_pending_template)
4393 TREE_CHAIN (last_pending_template) = pt;
4395 pending_templates = pt;
4397 last_pending_template = pt;
4399 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4406 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4407 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4408 documentation for TEMPLATE_ID_EXPR. */
4411 lookup_template_function (tree fns, tree arglist)
4415 if (fns == error_mark_node || arglist == error_mark_node)
4416 return error_mark_node;
4418 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
4419 gcc_assert (fns && (is_overloaded_fn (fns)
4420 || TREE_CODE (fns) == IDENTIFIER_NODE));
4422 if (BASELINK_P (fns))
4424 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
4426 BASELINK_FUNCTIONS (fns),
4431 type = TREE_TYPE (fns);
4432 if (TREE_CODE (fns) == OVERLOAD || !type)
4433 type = unknown_type_node;
4435 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
4438 /* Within the scope of a template class S<T>, the name S gets bound
4439 (in build_self_reference) to a TYPE_DECL for the class, not a
4440 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4441 or one of its enclosing classes, and that type is a template,
4442 return the associated TEMPLATE_DECL. Otherwise, the original
4443 DECL is returned. */
4446 maybe_get_template_decl_from_type_decl (tree decl)
4448 return (decl != NULL_TREE
4449 && TREE_CODE (decl) == TYPE_DECL
4450 && DECL_ARTIFICIAL (decl)
4451 && CLASS_TYPE_P (TREE_TYPE (decl))
4452 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4453 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4456 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4457 parameters, find the desired type.
4459 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4461 IN_DECL, if non-NULL, is the template declaration we are trying to
4464 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4465 the class we are looking up.
4467 Issue error and warning messages under control of COMPLAIN.
4469 If the template class is really a local class in a template
4470 function, then the FUNCTION_CONTEXT is the function in which it is
4473 ??? Note that this function is currently called *twice* for each
4474 template-id: the first time from the parser, while creating the
4475 incomplete type (finish_template_type), and the second type during the
4476 real instantiation (instantiate_template_class). This is surely something
4477 that we want to avoid. It also causes some problems with argument
4478 coercion (see convert_nontype_argument for more information on this). */
4481 lookup_template_class (tree d1,
4486 tsubst_flags_t complain)
4488 tree template = NULL_TREE, parmlist;
4491 timevar_push (TV_NAME_LOOKUP);
4493 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4495 tree value = innermost_non_namespace_value (d1);
4496 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
4501 push_decl_namespace (context);
4502 template = lookup_name (d1);
4503 template = maybe_get_template_decl_from_type_decl (template);
4505 pop_decl_namespace ();
4508 context = DECL_CONTEXT (template);
4510 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4512 tree type = TREE_TYPE (d1);
4514 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4515 an implicit typename for the second A. Deal with it. */
4516 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4517 type = TREE_TYPE (type);
4519 if (CLASSTYPE_TEMPLATE_INFO (type))
4521 template = CLASSTYPE_TI_TEMPLATE (type);
4522 d1 = DECL_NAME (template);
4525 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4526 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4528 template = TYPE_TI_TEMPLATE (d1);
4529 d1 = DECL_NAME (template);
4531 else if (TREE_CODE (d1) == TEMPLATE_DECL
4532 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4535 d1 = DECL_NAME (template);
4536 context = DECL_CONTEXT (template);
4539 /* Issue an error message if we didn't find a template. */
4542 if (complain & tf_error)
4543 error ("%qT is not a template", d1);
4544 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4547 if (TREE_CODE (template) != TEMPLATE_DECL
4548 /* Make sure it's a user visible template, if it was named by
4550 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4551 && !PRIMARY_TEMPLATE_P (template)))
4553 if (complain & tf_error)
4555 error ("non-template type %qT used as a template", d1);
4557 error ("for template declaration %q+D", in_decl);
4559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4562 complain &= ~tf_user;
4564 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4566 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4567 template arguments */
4572 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4574 /* Consider an example where a template template parameter declared as
4576 template <class T, class U = std::allocator<T> > class TT
4578 The template parameter level of T and U are one level larger than
4579 of TT. To proper process the default argument of U, say when an
4580 instantiation `TT<int>' is seen, we need to build the full
4581 arguments containing {int} as the innermost level. Outer levels,
4582 available when not appearing as default template argument, can be
4583 obtained from `current_template_args ()'.
4585 Suppose that TT is later substituted with std::vector. The above
4586 instantiation is `TT<int, std::allocator<T> >' with TT at
4587 level 1, and T at level 2, while the template arguments at level 1
4588 becomes {std::vector} and the inner level 2 is {int}. */
4590 if (current_template_parms)
4591 arglist = add_to_template_args (current_template_args (), arglist);
4593 arglist2 = coerce_template_parms (parmlist, arglist, template,
4595 /*require_all_args=*/true,
4596 /*use_default_args=*/true);
4597 if (arglist2 == error_mark_node
4598 || (!uses_template_parms (arglist2)
4599 && check_instantiated_args (template, arglist2, complain)))
4600 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4602 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4603 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4607 tree template_type = TREE_TYPE (template);
4610 tree found = NULL_TREE;
4613 int is_partial_instantiation;
4615 gen_tmpl = most_general_template (template);
4616 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4617 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4618 arg_depth = TMPL_ARGS_DEPTH (arglist);
4620 if (arg_depth == 1 && parm_depth > 1)
4622 /* We've been given an incomplete set of template arguments.
4625 template <class T> struct S1 {
4626 template <class U> struct S2 {};
4627 template <class U> struct S2<U*> {};
4630 we will be called with an ARGLIST of `U*', but the
4631 TEMPLATE will be `template <class T> template
4632 <class U> struct S1<T>::S2'. We must fill in the missing
4635 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4637 arg_depth = TMPL_ARGS_DEPTH (arglist);
4640 /* Now we should have enough arguments. */
4641 gcc_assert (parm_depth == arg_depth);
4643 /* From here on, we're only interested in the most general
4645 template = gen_tmpl;
4647 /* Calculate the BOUND_ARGS. These will be the args that are
4648 actually tsubst'd into the definition to create the
4652 /* We have multiple levels of arguments to coerce, at once. */
4654 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4656 tree bound_args = make_tree_vec (parm_depth);
4658 for (i = saved_depth,
4659 t = DECL_TEMPLATE_PARMS (template);
4660 i > 0 && t != NULL_TREE;
4661 --i, t = TREE_CHAIN (t))
4663 tree a = coerce_template_parms (TREE_VALUE (t),
4666 /*require_all_args=*/true,
4667 /*use_default_args=*/true);
4669 /* Don't process further if one of the levels fails. */
4670 if (a == error_mark_node)
4672 /* Restore the ARGLIST to its full size. */
4673 TREE_VEC_LENGTH (arglist) = saved_depth;
4674 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4677 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4679 /* We temporarily reduce the length of the ARGLIST so
4680 that coerce_template_parms will see only the arguments
4681 corresponding to the template parameters it is
4683 TREE_VEC_LENGTH (arglist)--;
4686 /* Restore the ARGLIST to its full size. */
4687 TREE_VEC_LENGTH (arglist) = saved_depth;
4689 arglist = bound_args;
4693 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4694 INNERMOST_TEMPLATE_ARGS (arglist),
4697 /*require_all_args=*/true,
4698 /*use_default_args=*/true);
4700 if (arglist == error_mark_node)
4701 /* We were unable to bind the arguments. */
4702 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4704 /* In the scope of a template class, explicit references to the
4705 template class refer to the type of the template, not any
4706 instantiation of it. For example, in:
4708 template <class T> class C { void f(C<T>); }
4710 the `C<T>' is just the same as `C'. Outside of the
4711 class, however, such a reference is an instantiation. */
4712 if (comp_template_args (TYPE_TI_ARGS (template_type),
4715 found = template_type;
4717 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4721 for (ctx = current_class_type;
4722 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4724 ? TYPE_CONTEXT (ctx)
4725 : DECL_CONTEXT (ctx)))
4726 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4729 /* We're not in the scope of the class, so the
4730 TEMPLATE_TYPE is not the type we want after all. */
4736 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4738 /* If we already have this specialization, return it. */
4739 found = retrieve_specialization (template, arglist,
4740 /*class_specializations_p=*/false);
4742 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4744 /* This type is a "partial instantiation" if any of the template
4745 arguments still involve template parameters. Note that we set
4746 IS_PARTIAL_INSTANTIATION for partial specializations as
4748 is_partial_instantiation = uses_template_parms (arglist);
4750 /* If the deduced arguments are invalid, then the binding
4752 if (!is_partial_instantiation
4753 && check_instantiated_args (template,
4754 INNERMOST_TEMPLATE_ARGS (arglist),
4756 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4758 if (!is_partial_instantiation
4759 && !PRIMARY_TEMPLATE_P (template)
4760 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4762 found = xref_tag_from_type (TREE_TYPE (template),
4763 DECL_NAME (template),
4764 /*tag_scope=*/ts_global);
4765 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4768 context = tsubst (DECL_CONTEXT (template), arglist,
4771 context = global_namespace;
4773 /* Create the type. */
4774 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4776 if (!is_partial_instantiation)
4778 set_current_access_from_decl (TYPE_NAME (template_type));
4779 t = start_enum (TYPE_IDENTIFIER (template_type));
4782 /* We don't want to call start_enum for this type, since
4783 the values for the enumeration constants may involve
4784 template parameters. And, no one should be interested
4785 in the enumeration constants for such a type. */
4786 t = make_node (ENUMERAL_TYPE);
4790 t = make_aggr_type (TREE_CODE (template_type));
4791 CLASSTYPE_DECLARED_CLASS (t)
4792 = CLASSTYPE_DECLARED_CLASS (template_type);
4793 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4794 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4796 /* A local class. Make sure the decl gets registered properly. */
4797 if (context == current_function_decl)
4798 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
4801 /* If we called start_enum or pushtag above, this information
4802 will already be set up. */
4805 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4807 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4808 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4809 TYPE_STUB_DECL (t) = type_decl;
4810 DECL_SOURCE_LOCATION (type_decl)
4811 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4814 type_decl = TYPE_NAME (t);
4816 TREE_PRIVATE (type_decl)
4817 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4818 TREE_PROTECTED (type_decl)
4819 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4820 DECL_IN_SYSTEM_HEADER (type_decl)
4821 = DECL_IN_SYSTEM_HEADER (template);
4822 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
4824 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
4825 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
4828 /* Set up the template information. We have to figure out which
4829 template is the immediate parent if this is a full
4831 if (parm_depth == 1 || is_partial_instantiation
4832 || !PRIMARY_TEMPLATE_P (template))
4833 /* This case is easy; there are no member templates involved. */
4837 /* This is a full instantiation of a member template. Look
4838 for a partial instantiation of which this is an instance. */
4840 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4841 found; found = TREE_CHAIN (found))
4844 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4846 /* We only want partial instantiations, here, not
4847 specializations or full instantiations. */
4848 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4849 || !uses_template_parms (TREE_VALUE (found)))
4852 /* Temporarily reduce by one the number of levels in the
4853 ARGLIST and in FOUND so as to avoid comparing the
4854 last set of arguments. */
4855 TREE_VEC_LENGTH (arglist)--;
4856 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4858 /* See if the arguments match. If they do, then TMPL is
4859 the partial instantiation we want. */
4860 success = comp_template_args (TREE_PURPOSE (found), arglist);
4862 /* Restore the argument vectors to their full size. */
4863 TREE_VEC_LENGTH (arglist)++;
4864 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4875 /* There was no partial instantiation. This happens
4876 where C<T> is a member template of A<T> and it's used
4879 template <typename T> struct B { A<T>::C<int> m; };
4882 Create the partial instantiation.
4884 TREE_VEC_LENGTH (arglist)--;
4885 found = tsubst (template, arglist, complain, NULL_TREE);
4886 TREE_VEC_LENGTH (arglist)++;
4890 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4891 DECL_TEMPLATE_INSTANTIATIONS (template)
4892 = tree_cons (arglist, t,
4893 DECL_TEMPLATE_INSTANTIATIONS (template));
4895 if (TREE_CODE (t) == ENUMERAL_TYPE
4896 && !is_partial_instantiation)
4897 /* Now that the type has been registered on the instantiations
4898 list, we set up the enumerators. Because the enumeration
4899 constants may involve the enumeration type itself, we make
4900 sure to register the type first, and then create the
4901 constants. That way, doing tsubst_expr for the enumeration
4902 constants won't result in recursive calls here; we'll find
4903 the instantiation and exit above. */
4904 tsubst_enum (template_type, t, arglist);
4906 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4908 if (TREE_CODE (t) != ENUMERAL_TYPE)
4909 DECL_NAME (type_decl) = classtype_mangled_name (t);
4910 if (is_partial_instantiation)
4911 /* If the type makes use of template parameters, the
4912 code that generates debugging information will crash. */
4913 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4915 /* Possibly limit visibility based on template args. */
4916 TREE_PUBLIC (type_decl) = 1;
4917 determine_visibility (type_decl);
4919 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4921 timevar_pop (TV_NAME_LOOKUP);
4928 struct pointer_set_t *visited;
4931 /* Called from for_each_template_parm via walk_tree. */
4934 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
4937 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4938 tree_fn_t fn = pfd->fn;
4939 void *data = pfd->data;
4942 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4943 return error_mark_node;
4945 switch (TREE_CODE (t))
4948 if (TYPE_PTRMEMFUNC_P (t))
4954 if (!TYPE_TEMPLATE_INFO (t))
4956 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4957 fn, data, pfd->visited))
4958 return error_mark_node;
4962 /* Since we're not going to walk subtrees, we have to do this
4964 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4966 return error_mark_node;
4970 /* Check the return type. */
4971 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4972 return error_mark_node;
4974 /* Check the parameter types. Since default arguments are not
4975 instantiated until they are needed, the TYPE_ARG_TYPES may
4976 contain expressions that involve template parameters. But,
4977 no-one should be looking at them yet. And, once they're
4978 instantiated, they don't contain template parameters, so
4979 there's no point in looking at them then, either. */
4983 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4984 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
4986 return error_mark_node;
4988 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4989 want walk_tree walking into them itself. */
4995 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
4997 return error_mark_node;
5002 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
5003 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
5005 return error_mark_node;
5010 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
5011 && for_each_template_parm (DECL_INITIAL (t), fn, data,
5013 return error_mark_node;
5014 if (DECL_CONTEXT (t)
5015 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
5017 return error_mark_node;
5020 case BOUND_TEMPLATE_TEMPLATE_PARM:
5021 /* Record template parameters such as `T' inside `TT<T>'. */
5022 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
5023 return error_mark_node;
5026 case TEMPLATE_TEMPLATE_PARM:
5027 case TEMPLATE_TYPE_PARM:
5028 case TEMPLATE_PARM_INDEX:
5029 if (fn && (*fn)(t, data))
5030 return error_mark_node;
5032 return error_mark_node;
5036 /* A template template parameter is encountered. */
5037 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
5038 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5039 return error_mark_node;
5041 /* Already substituted template template parameter */
5047 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
5048 data, pfd->visited))
5049 return error_mark_node;
5053 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
5054 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
5055 (TREE_TYPE (t)), fn, data,
5057 return error_mark_node;
5062 /* If there's no type, then this thing must be some expression
5063 involving template parameters. */
5064 if (!fn && !TREE_TYPE (t))
5065 return error_mark_node;
5070 case REINTERPRET_CAST_EXPR:
5071 case CONST_CAST_EXPR:
5072 case STATIC_CAST_EXPR:
5073 case DYNAMIC_CAST_EXPR:
5077 case PSEUDO_DTOR_EXPR:
5079 return error_mark_node;
5083 /* If we do not handle this case specially, we end up walking
5084 the BINFO hierarchy, which is circular, and therefore
5085 confuses walk_tree. */
5087 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
5089 return error_mark_node;
5096 /* We didn't find any template parameters we liked. */
5100 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
5101 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
5102 call FN with the parameter and the DATA.
5103 If FN returns nonzero, the iteration is terminated, and
5104 for_each_template_parm returns 1. Otherwise, the iteration
5105 continues. If FN never returns a nonzero value, the value
5106 returned by for_each_template_parm is 0. If FN is NULL, it is
5107 considered to be the function which always returns 1. */
5110 for_each_template_parm (tree t, tree_fn_t fn, void* data,
5111 struct pointer_set_t *visited)
5113 struct pair_fn_data pfd;
5120 /* Walk the tree. (Conceptually, we would like to walk without
5121 duplicates, but for_each_template_parm_r recursively calls
5122 for_each_template_parm, so we would need to reorganize a fair
5123 bit to use walk_tree_without_duplicates, so we keep our own
5126 pfd.visited = visited;
5128 pfd.visited = pointer_set_create ();
5129 result = walk_tree (&t,
5130 for_each_template_parm_r,
5132 pfd.visited) != NULL_TREE;
5137 pointer_set_destroy (pfd.visited);
5144 /* Returns true if T depends on any template parameter. */
5147 uses_template_parms (tree t)
5150 int saved_processing_template_decl;
5152 saved_processing_template_decl = processing_template_decl;
5153 if (!saved_processing_template_decl)
5154 processing_template_decl = 1;
5156 dependent_p = dependent_type_p (t);
5157 else if (TREE_CODE (t) == TREE_VEC)
5158 dependent_p = any_dependent_template_arguments_p (t);
5159 else if (TREE_CODE (t) == TREE_LIST)
5160 dependent_p = (uses_template_parms (TREE_VALUE (t))
5161 || uses_template_parms (TREE_CHAIN (t)));
5162 else if (TREE_CODE (t) == TYPE_DECL)
5163 dependent_p = dependent_type_p (TREE_TYPE (t));
5166 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
5167 || TREE_CODE (t) == OVERLOAD
5168 || TREE_CODE (t) == BASELINK
5169 || TREE_CODE (t) == IDENTIFIER_NODE
5170 || CONSTANT_CLASS_P (t))
5171 dependent_p = (type_dependent_expression_p (t)
5172 || value_dependent_expression_p (t));
5175 gcc_assert (t == error_mark_node);
5176 dependent_p = false;
5179 processing_template_decl = saved_processing_template_decl;
5184 /* Returns true if T depends on any template parameter with level LEVEL. */
5187 uses_template_parms_level (tree t, int level)
5189 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
5192 static int tinst_depth;
5193 extern int max_tinst_depth;
5194 #ifdef GATHER_STATISTICS
5197 static int tinst_level_tick;
5198 static int last_template_error_tick;
5200 /* We're starting to instantiate D; record the template instantiation context
5201 for diagnostics and to restore it later. */
5204 push_tinst_level (tree d)
5208 if (tinst_depth >= max_tinst_depth)
5210 /* If the instantiation in question still has unbound template parms,
5211 we don't really care if we can't instantiate it, so just return.
5212 This happens with base instantiation for implicit `typename'. */
5213 if (uses_template_parms (d))
5216 last_template_error_tick = tinst_level_tick;
5217 error ("template instantiation depth exceeds maximum of %d (use "
5218 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
5219 max_tinst_depth, d);
5221 print_instantiation_context ();
5226 new = make_node (TINST_LEVEL);
5227 TINST_DECL (new) = d;
5228 TINST_LOCATION (new) = input_location;
5229 TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
5230 TREE_CHAIN (new) = current_tinst_level;
5231 current_tinst_level = new;
5234 #ifdef GATHER_STATISTICS
5235 if (tinst_depth > depth_reached)
5236 depth_reached = tinst_depth;
5243 /* We're done instantiating this template; return to the instantiation
5247 pop_tinst_level (void)
5249 tree old = current_tinst_level;
5251 /* Restore the filename and line number stashed away when we started
5252 this instantiation. */
5253 input_location = TINST_LOCATION (old);
5254 in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
5255 current_tinst_level = TREE_CHAIN (old);
5260 /* We're instantiating a deferred template; restore the template
5261 instantiation context in which the instantiation was requested, which
5262 is one step out from LEVEL. */
5265 reopen_tinst_level (tree level)
5270 for (t = level; t; t = TREE_CHAIN (t))
5273 current_tinst_level = level;
5277 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
5278 vector of template arguments, as for tsubst.
5280 Returns an appropriate tsubst'd friend declaration. */
5283 tsubst_friend_function (tree decl, tree args)
5287 if (TREE_CODE (decl) == FUNCTION_DECL
5288 && DECL_TEMPLATE_INSTANTIATION (decl)
5289 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
5290 /* This was a friend declared with an explicit template
5291 argument list, e.g.:
5295 to indicate that f was a template instantiation, not a new
5296 function declaration. Now, we have to figure out what
5297 instantiation of what template. */
5299 tree template_id, arglist, fns;
5302 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
5304 /* Friend functions are looked up in the containing namespace scope.
5305 We must enter that scope, to avoid finding member functions of the
5306 current cless with same name. */
5307 push_nested_namespace (ns);
5308 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
5309 tf_warning_or_error, NULL_TREE,
5310 /*integral_constant_expression_p=*/false);
5311 pop_nested_namespace (ns);
5312 arglist = tsubst (DECL_TI_ARGS (decl), args,
5313 tf_warning_or_error, NULL_TREE);
5314 template_id = lookup_template_function (fns, arglist);
5316 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5317 tmpl = determine_specialization (template_id, new_friend,
5319 /*need_member_template=*/0,
5320 TREE_VEC_LENGTH (args),
5322 return instantiate_template (tmpl, new_args, tf_error);
5325 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5327 /* The NEW_FRIEND will look like an instantiation, to the
5328 compiler, but is not an instantiation from the point of view of
5329 the language. For example, we might have had:
5331 template <class T> struct S {
5332 template <class U> friend void f(T, U);
5335 Then, in S<int>, template <class U> void f(int, U) is not an
5336 instantiation of anything. */
5337 if (new_friend == error_mark_node)
5338 return error_mark_node;
5340 DECL_USE_TEMPLATE (new_friend) = 0;
5341 if (TREE_CODE (decl) == TEMPLATE_DECL)
5343 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
5344 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
5345 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5348 /* The mangled name for the NEW_FRIEND is incorrect. The function
5349 is not a template instantiation and should not be mangled like
5350 one. Therefore, we forget the mangling here; we'll recompute it
5351 later if we need it. */
5352 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5354 SET_DECL_RTL (new_friend, NULL_RTX);
5355 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5358 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5361 tree new_friend_template_info;
5362 tree new_friend_result_template_info;
5364 int new_friend_is_defn;
5366 /* We must save some information from NEW_FRIEND before calling
5367 duplicate decls since that function will free NEW_FRIEND if
5369 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5370 new_friend_is_defn =
5371 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5372 (template_for_substitution (new_friend)))
5374 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5376 /* This declaration is a `primary' template. */
5377 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5379 new_friend_result_template_info
5380 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5383 new_friend_result_template_info = NULL_TREE;
5385 /* Make the init_value nonzero so pushdecl knows this is a defn. */
5386 if (new_friend_is_defn)
5387 DECL_INITIAL (new_friend) = error_mark_node;
5389 /* Inside pushdecl_namespace_level, we will push into the
5390 current namespace. However, the friend function should go
5391 into the namespace of the template. */
5392 ns = decl_namespace_context (new_friend);
5393 push_nested_namespace (ns);
5394 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
5395 pop_nested_namespace (ns);
5397 if (old_decl == error_mark_node)
5398 return error_mark_node;
5400 if (old_decl != new_friend)
5402 /* This new friend declaration matched an existing
5403 declaration. For example, given:
5405 template <class T> void f(T);
5406 template <class U> class C {
5407 template <class T> friend void f(T) {}
5410 the friend declaration actually provides the definition
5411 of `f', once C has been instantiated for some type. So,
5412 old_decl will be the out-of-class template declaration,
5413 while new_friend is the in-class definition.
5415 But, if `f' was called before this point, the
5416 instantiation of `f' will have DECL_TI_ARGS corresponding
5417 to `T' but not to `U', references to which might appear
5418 in the definition of `f'. Previously, the most general
5419 template for an instantiation of `f' was the out-of-class
5420 version; now it is the in-class version. Therefore, we
5421 run through all specialization of `f', adding to their
5422 DECL_TI_ARGS appropriately. In particular, they need a
5423 new set of outer arguments, corresponding to the
5424 arguments for this class instantiation.
5426 The same situation can arise with something like this:
5429 template <class T> class C {
5433 when `C<int>' is instantiated. Now, `f(int)' is defined
5436 if (!new_friend_is_defn)
5437 /* On the other hand, if the in-class declaration does
5438 *not* provide a definition, then we don't want to alter
5439 existing definitions. We can just leave everything
5444 /* Overwrite whatever template info was there before, if
5445 any, with the new template information pertaining to
5447 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5449 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5450 reregister_specialization (new_friend,
5451 most_general_template (old_decl),
5456 tree new_friend_args;
5458 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5459 = new_friend_result_template_info;
5461 new_friend_args = TI_ARGS (new_friend_template_info);
5462 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5466 tree spec = TREE_VALUE (t);
5469 = add_outermost_template_args (new_friend_args,
5470 DECL_TI_ARGS (spec));
5473 /* Now, since specializations are always supposed to
5474 hang off of the most general template, we must move
5476 t = most_general_template (old_decl);
5479 DECL_TEMPLATE_SPECIALIZATIONS (t)
5480 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5481 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5482 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5487 /* The information from NEW_FRIEND has been merged into OLD_DECL
5488 by duplicate_decls. */
5489 new_friend = old_decl;
5494 tree context = DECL_CONTEXT (new_friend);
5498 template <class T> class C {
5499 template <class U> friend void C1<U>::f (); // case 1
5500 friend void C2<T>::f (); // case 2
5502 we only need to make sure CONTEXT is a complete type for
5503 case 2. To distinguish between the two cases, we note that
5504 CONTEXT of case 1 remains dependent type after tsubst while
5505 this isn't true for case 2. */
5506 ++processing_template_decl;
5507 dependent_p = dependent_type_p (context);
5508 --processing_template_decl;
5511 && !complete_type_or_else (context, NULL_TREE))
5512 return error_mark_node;
5514 if (COMPLETE_TYPE_P (context))
5516 /* Check to see that the declaration is really present, and,
5517 possibly obtain an improved declaration. */
5518 tree fn = check_classfn (context,
5519 new_friend, NULL_TREE);
5529 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5530 template arguments, as for tsubst.
5532 Returns an appropriate tsubst'd friend type or error_mark_node on
5536 tsubst_friend_class (tree friend_tmpl, tree args)
5542 context = DECL_CONTEXT (friend_tmpl);
5546 if (TREE_CODE (context) == NAMESPACE_DECL)
5547 push_nested_namespace (context);
5549 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5552 /* Look for a class template declaration. We look for hidden names
5553 because two friend declarations of the same template are the
5554 same. For example, in:
5557 template <typename> friend class F;
5559 template <typename> struct B {
5560 template <typename> friend class F;
5563 both F templates are the same. */
5564 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
5565 /*block_p=*/true, 0,
5566 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
5568 /* But, if we don't find one, it might be because we're in a
5569 situation like this:
5577 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5578 for `S<int>', not the TEMPLATE_DECL. */
5579 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5581 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
5582 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5585 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5587 /* The friend template has already been declared. Just
5588 check to see that the declarations match, and install any new
5589 default parameters. We must tsubst the default parameters,
5590 of course. We only need the innermost template parameters
5591 because that is all that redeclare_class_template will look
5593 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5594 > TMPL_ARGS_DEPTH (args))
5597 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5598 args, tf_warning_or_error);
5599 redeclare_class_template (TREE_TYPE (tmpl), parms);
5602 friend_type = TREE_TYPE (tmpl);
5606 /* The friend template has not already been declared. In this
5607 case, the instantiation of the template class will cause the
5608 injection of this template into the global scope. */
5609 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
5610 if (tmpl == error_mark_node)
5611 return error_mark_node;
5613 /* The new TMPL is not an instantiation of anything, so we
5614 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5615 the new type because that is supposed to be the corresponding
5616 template decl, i.e., TMPL. */
5617 DECL_USE_TEMPLATE (tmpl) = 0;
5618 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5619 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5620 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5621 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5623 /* Inject this template into the global scope. */
5624 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
5629 if (TREE_CODE (context) == NAMESPACE_DECL)
5630 pop_nested_namespace (context);
5632 pop_nested_class ();
5638 /* Returns zero if TYPE cannot be completed later due to circularity.
5639 Otherwise returns one. */
5642 can_complete_type_without_circularity (tree type)
5644 if (type == NULL_TREE || type == error_mark_node)
5646 else if (COMPLETE_TYPE_P (type))
5648 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5649 return can_complete_type_without_circularity (TREE_TYPE (type));
5650 else if (CLASS_TYPE_P (type)
5651 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5658 instantiate_class_template (tree type)
5660 tree template, args, pattern, t, member;
5665 if (type == error_mark_node)
5666 return error_mark_node;
5668 if (TYPE_BEING_DEFINED (type)
5669 || COMPLETE_TYPE_P (type)
5670 || dependent_type_p (type))
5673 /* Figure out which template is being instantiated. */
5674 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5675 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
5677 /* Determine what specialization of the original template to
5679 t = most_specialized_class (type, template);
5680 if (t == error_mark_node)
5682 TYPE_BEING_DEFINED (type) = 1;
5683 return error_mark_node;
5687 /* This TYPE is actually an instantiation of a partial
5688 specialization. We replace the innermost set of ARGS with
5689 the arguments appropriate for substitution. For example,
5692 template <class T> struct S {};
5693 template <class T> struct S<T*> {};
5695 and supposing that we are instantiating S<int*>, ARGS will
5696 presently be {int*} -- but we need {int}. */
5697 pattern = TREE_TYPE (t);
5698 args = TREE_PURPOSE (t);
5702 pattern = TREE_TYPE (template);
5703 args = CLASSTYPE_TI_ARGS (type);
5706 /* If the template we're instantiating is incomplete, then clearly
5707 there's nothing we can do. */
5708 if (!COMPLETE_TYPE_P (pattern))
5711 /* If we've recursively instantiated too many templates, stop. */
5712 if (! push_tinst_level (type))
5715 /* Now we're really doing the instantiation. Mark the type as in
5716 the process of being defined. */
5717 TYPE_BEING_DEFINED (type) = 1;
5719 /* We may be in the middle of deferred access check. Disable
5721 push_deferring_access_checks (dk_no_deferred);
5723 push_to_top_level ();
5725 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5727 /* Set the input location to the template definition. This is needed
5728 if tsubsting causes an error. */
5729 typedecl = TYPE_MAIN_DECL (type);
5730 input_location = DECL_SOURCE_LOCATION (typedecl);
5731 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
5733 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5734 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5735 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5736 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5737 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5738 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5739 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5740 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5741 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5742 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5743 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5744 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5745 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5746 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5747 if (ANON_AGGR_TYPE_P (pattern))
5748 SET_ANON_AGGR_TYPE_P (type);
5749 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
5751 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
5752 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
5755 pbinfo = TYPE_BINFO (pattern);
5757 /* We should never instantiate a nested class before its enclosing
5758 class; we need to look up the nested class by name before we can
5759 instantiate it, and that lookup should instantiate the enclosing
5761 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5762 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5763 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
5765 base_list = NULL_TREE;
5766 if (BINFO_N_BASE_BINFOS (pbinfo))
5769 tree context = TYPE_CONTEXT (type);
5773 /* We must enter the scope containing the type, as that is where
5774 the accessibility of types named in dependent bases are
5776 pushed_scope = push_scope (context ? context : global_namespace);
5778 /* Substitute into each of the bases to determine the actual
5780 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
5783 tree access = BINFO_BASE_ACCESS (pbinfo, i);
5785 /* Substitute to figure out the base class. */
5786 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
5787 if (base == error_mark_node)
5790 base_list = tree_cons (access, base, base_list);
5791 if (BINFO_VIRTUAL_P (pbase_binfo))
5792 TREE_TYPE (base_list) = integer_type_node;
5795 /* The list is now in reverse order; correct that. */
5796 base_list = nreverse (base_list);
5799 pop_scope (pushed_scope);
5801 /* Now call xref_basetypes to set up all the base-class
5803 xref_basetypes (type, base_list);
5806 /* Now that our base classes are set up, enter the scope of the
5807 class, so that name lookups into base classes, etc. will work
5808 correctly. This is precisely analogous to what we do in
5809 begin_class_definition when defining an ordinary non-template
5813 /* Now members are processed in the order of declaration. */
5814 for (member = CLASSTYPE_DECL_LIST (pattern);
5815 member; member = TREE_CHAIN (member))
5817 tree t = TREE_VALUE (member);
5819 if (TREE_PURPOSE (member))
5823 /* Build new CLASSTYPE_NESTED_UTDS. */
5826 bool class_template_p;
5828 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
5829 && TYPE_LANG_SPECIFIC (t)
5830 && CLASSTYPE_IS_TEMPLATE (t));
5831 /* If the member is a class template, then -- even after
5832 substitution -- there may be dependent types in the
5833 template argument list for the class. We increment
5834 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5835 that function will assume that no types are dependent
5836 when outside of a template. */
5837 if (class_template_p)
5838 ++processing_template_decl;
5839 newtag = tsubst (t, args, tf_error, NULL_TREE);
5840 if (class_template_p)
5841 --processing_template_decl;
5842 if (newtag == error_mark_node)
5845 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5847 tree name = TYPE_IDENTIFIER (t);
5849 if (class_template_p)
5850 /* Unfortunately, lookup_template_class sets
5851 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5852 instantiation (i.e., for the type of a member
5853 template class nested within a template class.)
5854 This behavior is required for
5855 maybe_process_partial_specialization to work
5856 correctly, but is not accurate in this case;
5857 the TAG is not an instantiation of anything.
5858 (The corresponding TEMPLATE_DECL is an
5859 instantiation, but the TYPE is not.) */
5860 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5862 /* Now, we call pushtag to put this NEWTAG into the scope of
5863 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5864 pushtag calling push_template_decl. We don't have to do
5865 this for enums because it will already have been done in
5868 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5869 pushtag (name, newtag, /*tag_scope=*/ts_current);
5872 else if (TREE_CODE (t) == FUNCTION_DECL
5873 || DECL_FUNCTION_TEMPLATE_P (t))
5875 /* Build new TYPE_METHODS. */
5878 if (TREE_CODE (t) == TEMPLATE_DECL)
5879 ++processing_template_decl;
5880 r = tsubst (t, args, tf_error, NULL_TREE);
5881 if (TREE_CODE (t) == TEMPLATE_DECL)
5882 --processing_template_decl;
5883 set_current_access_from_decl (r);
5884 finish_member_declaration (r);
5888 /* Build new TYPE_FIELDS. */
5890 if (TREE_CODE (t) != CONST_DECL)
5894 /* The the file and line for this declaration, to
5895 assist in error message reporting. Since we
5896 called push_tinst_level above, we don't need to
5898 input_location = DECL_SOURCE_LOCATION (t);
5900 if (TREE_CODE (t) == TEMPLATE_DECL)
5901 ++processing_template_decl;
5902 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
5903 if (TREE_CODE (t) == TEMPLATE_DECL)
5904 --processing_template_decl;
5905 if (TREE_CODE (r) == VAR_DECL)
5909 [t]he initialization (and any associated
5910 side-effects) of a static data member does
5911 not occur unless the static data member is
5912 itself used in a way that requires the
5913 definition of the static data member to
5916 Therefore, we do not substitute into the
5917 initialized for the static data member here. */
5918 finish_static_data_member_decl
5921 /*init_const_expr_p=*/false,
5922 /*asmspec_tree=*/NULL_TREE,
5924 if (DECL_INITIALIZED_IN_CLASS_P (r))
5925 check_static_variable_definition (r, TREE_TYPE (r));
5927 else if (TREE_CODE (r) == FIELD_DECL)
5929 /* Determine whether R has a valid type and can be
5930 completed later. If R is invalid, then it is
5931 replaced by error_mark_node so that it will not be
5932 added to TYPE_FIELDS. */
5933 tree rtype = TREE_TYPE (r);
5934 if (can_complete_type_without_circularity (rtype))
5935 complete_type (rtype);
5937 if (!COMPLETE_TYPE_P (rtype))
5939 cxx_incomplete_type_error (r, rtype);
5940 r = error_mark_node;
5944 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5945 such a thing will already have been added to the field
5946 list by tsubst_enum in finish_member_declaration in the
5947 CLASSTYPE_NESTED_UTDS case above. */
5948 if (!(TREE_CODE (r) == TYPE_DECL
5949 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5950 && DECL_ARTIFICIAL (r)))
5952 set_current_access_from_decl (r);
5953 finish_member_declaration (r);
5960 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5962 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5964 tree friend_type = t;
5965 bool adjust_processing_template_decl = false;
5967 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5969 /* template <class T> friend class C; */
5970 friend_type = tsubst_friend_class (friend_type, args);
5971 adjust_processing_template_decl = true;
5973 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
5975 /* template <class T> friend class C::D; */
5976 friend_type = tsubst (friend_type, args,
5977 tf_warning_or_error, NULL_TREE);
5978 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5979 friend_type = TREE_TYPE (friend_type);
5980 adjust_processing_template_decl = true;
5982 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
5984 /* This could be either
5988 when dependent_type_p is false or
5990 template <class U> friend class T::C;
5993 friend_type = tsubst (friend_type, args,
5994 tf_warning_or_error, NULL_TREE);
5995 /* Bump processing_template_decl for correct
5996 dependent_type_p calculation. */
5997 ++processing_template_decl;
5998 if (dependent_type_p (friend_type))
5999 adjust_processing_template_decl = true;
6000 --processing_template_decl;
6002 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
6003 && hidden_name_p (TYPE_NAME (friend_type)))
6007 where C hasn't been declared yet. Let's lookup name
6008 from namespace scope directly, bypassing any name that
6009 come from dependent base class. */
6010 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
6012 /* The call to xref_tag_from_type does injection for friend
6014 push_nested_namespace (ns);
6016 xref_tag_from_type (friend_type, NULL_TREE,
6017 /*tag_scope=*/ts_current);
6018 pop_nested_namespace (ns);
6020 else if (uses_template_parms (friend_type))
6021 /* friend class C<T>; */
6022 friend_type = tsubst (friend_type, args,
6023 tf_warning_or_error, NULL_TREE);
6028 where C is already declared or
6030 friend class C<int>;
6032 We don't have to do anything in these cases. */
6034 if (adjust_processing_template_decl)
6035 /* Trick make_friend_class into realizing that the friend
6036 we're adding is a template, not an ordinary class. It's
6037 important that we use make_friend_class since it will
6038 perform some error-checking and output cross-reference
6040 ++processing_template_decl;
6042 if (friend_type != error_mark_node)
6043 make_friend_class (type, friend_type, /*complain=*/false);
6045 if (adjust_processing_template_decl)
6046 --processing_template_decl;
6050 /* Build new DECL_FRIENDLIST. */
6053 /* The the file and line for this declaration, to
6054 assist in error message reporting. Since we
6055 called push_tinst_level above, we don't need to
6057 input_location = DECL_SOURCE_LOCATION (t);
6059 if (TREE_CODE (t) == TEMPLATE_DECL)
6061 ++processing_template_decl;
6062 push_deferring_access_checks (dk_no_check);
6065 r = tsubst_friend_function (t, args);
6066 add_friend (type, r, /*complain=*/false);
6067 if (TREE_CODE (t) == TEMPLATE_DECL)
6069 pop_deferring_access_checks ();
6070 --processing_template_decl;
6076 /* Set the file and line number information to whatever is given for
6077 the class itself. This puts error messages involving generated
6078 implicit functions at a predictable point, and the same point
6079 that would be used for non-template classes. */
6080 input_location = DECL_SOURCE_LOCATION (typedecl);
6082 unreverse_member_declarations (type);
6083 finish_struct_1 (type);
6084 TYPE_BEING_DEFINED (type) = 0;
6086 /* Now that the class is complete, instantiate default arguments for
6087 any member functions. We don't do this earlier because the
6088 default arguments may reference members of the class. */
6089 if (!PRIMARY_TEMPLATE_P (template))
6090 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
6091 if (TREE_CODE (t) == FUNCTION_DECL
6092 /* Implicitly generated member functions will not have template
6093 information; they are not instantiations, but instead are
6094 created "fresh" for each instantiation. */
6095 && DECL_TEMPLATE_INFO (t))
6096 tsubst_default_arguments (t);
6099 pop_from_top_level ();
6100 pop_deferring_access_checks ();
6103 /* The vtable for a template class can be emitted in any translation
6104 unit in which the class is instantiated. When there is no key
6105 method, however, finish_struct_1 will already have added TYPE to
6106 the keyed_classes list. */
6107 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
6108 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
6114 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6120 else if (TYPE_P (t))
6121 r = tsubst (t, args, complain, in_decl);
6124 r = tsubst_expr (t, args, complain, in_decl,
6125 /*integral_constant_expression_p=*/true);
6126 r = fold_non_dependent_expr (r);
6131 /* Substitute ARGS into the vector or list of template arguments T. */
6134 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6136 int len = TREE_VEC_LENGTH (t);
6137 int need_new = 0, i;
6138 tree *elts = (tree *) alloca (len * sizeof (tree));
6140 for (i = 0; i < len; i++)
6142 tree orig_arg = TREE_VEC_ELT (t, i);
6145 if (TREE_CODE (orig_arg) == TREE_VEC)
6146 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
6148 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
6150 if (new_arg == error_mark_node)
6151 return error_mark_node;
6154 if (new_arg != orig_arg)
6161 t = make_tree_vec (len);
6162 for (i = 0; i < len; i++)
6163 TREE_VEC_ELT (t, i) = elts[i];
6168 /* Return the result of substituting ARGS into the template parameters
6169 given by PARMS. If there are m levels of ARGS and m + n levels of
6170 PARMS, then the result will contain n levels of PARMS. For
6171 example, if PARMS is `template <class T> template <class U>
6172 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
6173 result will be `template <int*, double, class V>'. */
6176 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
6181 /* When substituting into a template, we must set
6182 PROCESSING_TEMPLATE_DECL as the template parameters may be
6183 dependent if they are based on one-another, and the dependency
6184 predicates are short-circuit outside of templates. */
6185 ++processing_template_decl;
6187 for (new_parms = &r;
6188 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
6189 new_parms = &(TREE_CHAIN (*new_parms)),
6190 parms = TREE_CHAIN (parms))
6193 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
6196 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
6202 if (parms == error_mark_node)
6205 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
6207 if (tuple == error_mark_node)
6210 default_value = TREE_PURPOSE (tuple);
6211 parm_decl = TREE_VALUE (tuple);
6213 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
6214 if (TREE_CODE (parm_decl) == PARM_DECL
6215 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
6216 parm_decl = error_mark_node;
6217 default_value = tsubst_template_arg (default_value, args,
6218 complain, NULL_TREE);
6220 tuple = build_tree_list (default_value, parm_decl);
6221 TREE_VEC_ELT (new_vec, i) = tuple;
6225 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
6226 - TMPL_ARGS_DEPTH (args)),
6227 new_vec, NULL_TREE);
6230 --processing_template_decl;
6235 /* Substitute the ARGS into the indicated aggregate (or enumeration)
6236 type T. If T is not an aggregate or enumeration type, it is
6237 handled as if by tsubst. IN_DECL is as for tsubst. If
6238 ENTERING_SCOPE is nonzero, T is the context for a template which
6239 we are presently tsubst'ing. Return the substituted value. */
6242 tsubst_aggr_type (tree t,
6244 tsubst_flags_t complain,
6251 switch (TREE_CODE (t))
6254 if (TYPE_PTRMEMFUNC_P (t))
6255 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
6257 /* Else fall through. */
6260 if (TYPE_TEMPLATE_INFO (t))
6265 bool saved_skip_evaluation;
6267 /* In "sizeof(X<I>)" we need to evaluate "I". */
6268 saved_skip_evaluation = skip_evaluation;
6269 skip_evaluation = false;
6271 /* First, determine the context for the type we are looking
6273 context = TYPE_CONTEXT (t);
6275 context = tsubst_aggr_type (context, args, complain,
6276 in_decl, /*entering_scope=*/1);
6278 /* Then, figure out what arguments are appropriate for the
6279 type we are trying to find. For example, given:
6281 template <class T> struct S;
6282 template <class T, class U> void f(T, U) { S<U> su; }
6284 and supposing that we are instantiating f<int, double>,
6285 then our ARGS will be {int, double}, but, when looking up
6286 S we only want {double}. */
6287 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
6289 if (argvec == error_mark_node)
6290 r = error_mark_node;
6293 r = lookup_template_class (t, argvec, in_decl, context,
6294 entering_scope, complain);
6295 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6298 skip_evaluation = saved_skip_evaluation;
6303 /* This is not a template type, so there's nothing to do. */
6307 return tsubst (t, args, complain, in_decl);
6311 /* Substitute into the default argument ARG (a default argument for
6312 FN), which has the indicated TYPE. */
6315 tsubst_default_argument (tree fn, tree type, tree arg)
6317 tree saved_class_ptr = NULL_TREE;
6318 tree saved_class_ref = NULL_TREE;
6320 /* This default argument came from a template. Instantiate the
6321 default argument here, not in tsubst. In the case of
6330 we must be careful to do name lookup in the scope of S<T>,
6331 rather than in the current class. */
6332 push_access_scope (fn);
6333 /* The "this" pointer is not valid in a default argument. */
6336 saved_class_ptr = current_class_ptr;
6337 cp_function_chain->x_current_class_ptr = NULL_TREE;
6338 saved_class_ref = current_class_ref;
6339 cp_function_chain->x_current_class_ref = NULL_TREE;
6342 push_deferring_access_checks(dk_no_deferred);
6343 /* The default argument expression may cause implicitly defined
6344 member functions to be synthesized, which will result in garbage
6345 collection. We must treat this situation as if we were within
6346 the body of function so as to avoid collecting live data on the
6349 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
6350 tf_warning_or_error, NULL_TREE,
6351 /*integral_constant_expression_p=*/false);
6353 pop_deferring_access_checks();
6355 /* Restore the "this" pointer. */
6358 cp_function_chain->x_current_class_ptr = saved_class_ptr;
6359 cp_function_chain->x_current_class_ref = saved_class_ref;
6362 pop_access_scope (fn);
6364 /* Make sure the default argument is reasonable. */
6365 arg = check_default_argument (type, arg);
6370 /* Substitute into all the default arguments for FN. */
6373 tsubst_default_arguments (tree fn)
6378 tmpl_args = DECL_TI_ARGS (fn);
6380 /* If this function is not yet instantiated, we certainly don't need
6381 its default arguments. */
6382 if (uses_template_parms (tmpl_args))
6385 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
6387 arg = TREE_CHAIN (arg))
6388 if (TREE_PURPOSE (arg))
6389 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
6391 TREE_PURPOSE (arg));
6394 /* Substitute the ARGS into the T, which is a _DECL. Return the
6395 result of the substitution. Issue error and warning messages under
6396 control of COMPLAIN. */
6399 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
6401 location_t saved_loc;
6405 /* Set the filename and linenumber to improve error-reporting. */
6406 saved_loc = input_location;
6407 input_location = DECL_SOURCE_LOCATION (t);
6409 switch (TREE_CODE (t))
6413 /* We can get here when processing a member function template,
6414 member class template, and template template parameter of
6415 a template class. */
6416 tree decl = DECL_TEMPLATE_RESULT (t);
6421 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
6423 /* Template template parameter is treated here. */
6424 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6425 if (new_type == error_mark_node)
6426 return error_mark_node;
6429 TREE_CHAIN (r) = NULL_TREE;
6430 TREE_TYPE (r) = new_type;
6431 DECL_TEMPLATE_RESULT (r)
6432 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
6433 DECL_TEMPLATE_PARMS (r)
6434 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6436 TYPE_NAME (new_type) = r;
6440 /* We might already have an instance of this template.
6441 The ARGS are for the surrounding class type, so the
6442 full args contain the tsubst'd args for the context,
6443 plus the innermost args from the template decl. */
6444 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
6445 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
6446 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
6447 /* Because this is a template, the arguments will still be
6448 dependent, even after substitution. If
6449 PROCESSING_TEMPLATE_DECL is not set, the dependency
6450 predicates will short-circuit. */
6451 ++processing_template_decl;
6452 full_args = tsubst_template_args (tmpl_args, args,
6454 --processing_template_decl;
6455 if (full_args == error_mark_node)
6456 return error_mark_node;
6458 /* tsubst_template_args doesn't copy the vector if
6459 nothing changed. But, *something* should have
6461 gcc_assert (full_args != tmpl_args);
6463 spec = retrieve_specialization (t, full_args,
6464 /*class_specializations_p=*/true);
6465 if (spec != NULL_TREE)
6471 /* Make a new template decl. It will be similar to the
6472 original, but will record the current template arguments.
6473 We also create a new function declaration, which is just
6474 like the old one, but points to this new template, rather
6475 than the old one. */
6477 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
6478 TREE_CHAIN (r) = NULL_TREE;
6480 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6482 if (TREE_CODE (decl) == TYPE_DECL)
6485 ++processing_template_decl;
6486 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6487 --processing_template_decl;
6488 if (new_type == error_mark_node)
6489 return error_mark_node;
6491 TREE_TYPE (r) = new_type;
6492 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6493 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6494 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6495 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
6500 ++processing_template_decl;
6501 new_decl = tsubst (decl, args, complain, in_decl);
6502 --processing_template_decl;
6503 if (new_decl == error_mark_node)
6504 return error_mark_node;
6506 DECL_TEMPLATE_RESULT (r) = new_decl;
6507 DECL_TI_TEMPLATE (new_decl) = r;
6508 TREE_TYPE (r) = TREE_TYPE (new_decl);
6509 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6510 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
6513 SET_DECL_IMPLICIT_INSTANTIATION (r);
6514 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6515 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6517 /* The template parameters for this new template are all the
6518 template parameters for the old template, except the
6519 outermost level of parameters. */
6520 DECL_TEMPLATE_PARMS (r)
6521 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6524 if (PRIMARY_TEMPLATE_P (t))
6525 DECL_PRIMARY_TEMPLATE (r) = r;
6527 if (TREE_CODE (decl) != TYPE_DECL)
6528 /* Record this non-type partial instantiation. */
6529 register_specialization (r, t,
6530 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
6538 tree argvec = NULL_TREE;
6546 /* Nobody should be tsubst'ing into non-template functions. */
6547 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
6549 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6554 /* If T is not dependent, just return it. We have to
6555 increment PROCESSING_TEMPLATE_DECL because
6556 value_dependent_expression_p assumes that nothing is
6557 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6558 ++processing_template_decl;
6559 dependent_p = value_dependent_expression_p (t);
6560 --processing_template_decl;
6564 /* Calculate the most general template of which R is a
6565 specialization, and the complete set of arguments used to
6567 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6568 argvec = tsubst_template_args (DECL_TI_ARGS
6569 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6570 args, complain, in_decl);
6572 /* Check to see if we already have this specialization. */
6573 spec = retrieve_specialization (gen_tmpl, argvec,
6574 /*class_specializations_p=*/false);
6582 /* We can see more levels of arguments than parameters if
6583 there was a specialization of a member template, like
6586 template <class T> struct S { template <class U> void f(); }
6587 template <> template <class U> void S<int>::f(U);
6589 Here, we'll be substituting into the specialization,
6590 because that's where we can find the code we actually
6591 want to generate, but we'll have enough arguments for
6592 the most general template.
6594 We also deal with the peculiar case:
6596 template <class T> struct S {
6597 template <class U> friend void f();
6599 template <class U> void f() {}
6601 template void f<double>();
6603 Here, the ARGS for the instantiation of will be {int,
6604 double}. But, we only need as many ARGS as there are
6605 levels of template parameters in CODE_PATTERN. We are
6606 careful not to get fooled into reducing the ARGS in
6609 template <class T> struct S { template <class U> void f(U); }
6610 template <class T> template <> void S<T>::f(int) {}
6612 which we can spot because the pattern will be a
6613 specialization in this case. */
6614 args_depth = TMPL_ARGS_DEPTH (args);
6616 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6617 if (args_depth > parms_depth
6618 && !DECL_TEMPLATE_SPECIALIZATION (t))
6619 args = get_innermost_template_args (args, parms_depth);
6623 /* This special case arises when we have something like this:
6625 template <class T> struct S {
6626 friend void f<int>(int, double);
6629 Here, the DECL_TI_TEMPLATE for the friend declaration
6630 will be an IDENTIFIER_NODE. We are being called from
6631 tsubst_friend_function, and we want only to create a
6632 new decl (R) with appropriate types so that we can call
6633 determine_specialization. */
6634 gen_tmpl = NULL_TREE;
6637 if (DECL_CLASS_SCOPE_P (t))
6639 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6643 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6644 complain, t, /*entering_scope=*/1);
6649 ctx = DECL_CONTEXT (t);
6651 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6652 if (type == error_mark_node)
6653 return error_mark_node;
6655 /* We do NOT check for matching decls pushed separately at this
6656 point, as they may not represent instantiations of this
6657 template, and in any case are considered separate under the
6660 DECL_USE_TEMPLATE (r) = 0;
6661 TREE_TYPE (r) = type;
6662 /* Clear out the mangled name and RTL for the instantiation. */
6663 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6664 SET_DECL_RTL (r, NULL_RTX);
6665 DECL_INITIAL (r) = NULL_TREE;
6666 DECL_CONTEXT (r) = ctx;
6668 if (member && DECL_CONV_FN_P (r))
6669 /* Type-conversion operator. Reconstruct the name, in
6670 case it's the name of one of the template's parameters. */
6671 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6673 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6675 DECL_RESULT (r) = NULL_TREE;
6677 TREE_STATIC (r) = 0;
6678 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6679 DECL_EXTERNAL (r) = 1;
6680 /* If this is an instantiation of a function with internal
6681 linkage, we already know what object file linkage will be
6682 assigned to the instantiation. */
6683 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
6684 DECL_DEFER_OUTPUT (r) = 0;
6685 TREE_CHAIN (r) = NULL_TREE;
6686 DECL_PENDING_INLINE_INFO (r) = 0;
6687 DECL_PENDING_INLINE_P (r) = 0;
6688 DECL_SAVED_TREE (r) = NULL_TREE;
6690 if (DECL_CLONED_FUNCTION (r))
6692 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6694 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6695 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6698 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6699 this in the special friend case mentioned above where
6700 GEN_TMPL is NULL. */
6703 DECL_TEMPLATE_INFO (r)
6704 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6705 SET_DECL_IMPLICIT_INSTANTIATION (r);
6706 register_specialization (r, gen_tmpl, argvec, false);
6708 /* We're not supposed to instantiate default arguments
6709 until they are called, for a template. But, for a
6712 template <class T> void f ()
6713 { extern void g(int i = T()); }
6715 we should do the substitution when the template is
6716 instantiated. We handle the member function case in
6717 instantiate_class_template since the default arguments
6718 might refer to other members of the class. */
6720 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6721 && !uses_template_parms (argvec))
6722 tsubst_default_arguments (r);
6725 DECL_TEMPLATE_INFO (r) = NULL_TREE;
6727 /* Copy the list of befriending classes. */
6728 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6730 friends = &TREE_CHAIN (*friends))
6732 *friends = copy_node (*friends);
6733 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6738 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6740 maybe_retrofit_in_chrg (r);
6741 if (DECL_CONSTRUCTOR_P (r))
6742 grok_ctor_properties (ctx, r);
6743 /* If this is an instantiation of a member template, clone it.
6744 If it isn't, that'll be handled by
6745 clone_constructors_and_destructors. */
6746 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6747 clone_function_decl (r, /*update_method_vec_p=*/0);
6749 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
6750 && !grok_op_properties (r, (complain & tf_error) != 0))
6751 return error_mark_node;
6753 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6754 SET_DECL_FRIEND_CONTEXT (r,
6755 tsubst (DECL_FRIEND_CONTEXT (t),
6756 args, complain, in_decl));
6758 /* Possibly limit visibility based on template args. */
6759 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
6760 if (DECL_VISIBILITY_SPECIFIED (t))
6762 DECL_VISIBILITY_SPECIFIED (r) = 0;
6764 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
6766 determine_visibility (r);
6775 if (DECL_TEMPLATE_PARM_P (t))
6776 SET_DECL_TEMPLATE_PARM_P (r);
6778 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6779 type = type_decays_to (type);
6780 TREE_TYPE (r) = type;
6781 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6783 if (DECL_INITIAL (r))
6785 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6786 DECL_INITIAL (r) = TREE_TYPE (r);
6788 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6792 DECL_CONTEXT (r) = NULL_TREE;
6794 if (!DECL_TEMPLATE_PARM_P (r))
6795 DECL_ARG_TYPE (r) = type_passed_as (type);
6797 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6798 complain, TREE_CHAIN (t));
6807 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6808 if (type == error_mark_node)
6809 return error_mark_node;
6810 TREE_TYPE (r) = type;
6811 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6813 /* DECL_INITIAL gives the number of bits in a bit-field. */
6815 = tsubst_expr (DECL_INITIAL (t), args,
6817 /*integral_constant_expression_p=*/true);
6818 /* We don't have to set DECL_CONTEXT here; it is set by
6819 finish_member_declaration. */
6820 TREE_CHAIN (r) = NULL_TREE;
6821 if (VOID_TYPE_P (type))
6822 error ("instantiation of %q+D as type %qT", r, type);
6827 /* We reach here only for member using decls. */
6828 if (DECL_DEPENDENT_P (t))
6830 r = do_class_using_decl
6831 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
6832 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
6834 r = error_mark_node;
6839 TREE_CHAIN (r) = NULL_TREE;
6846 tree argvec = NULL_TREE;
6847 tree gen_tmpl = NULL_TREE;
6849 tree tmpl = NULL_TREE;
6851 tree type = NULL_TREE;
6854 if (TREE_CODE (t) == TYPE_DECL)
6856 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6857 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6858 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6860 /* If this is the canonical decl, we don't have to
6861 mess with instantiations, and often we can't (for
6862 typename, template type parms and such). Note that
6863 TYPE_NAME is not correct for the above test if
6864 we've copied the type for a typedef. */
6865 r = TYPE_NAME (type);
6870 /* Check to see if we already have the specialization we
6873 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
6875 /* T is a static data member or namespace-scope entity.
6876 We have to substitute into namespace-scope variables
6877 (even though such entities are never templates) because
6880 template <class T> void f() { extern T t; }
6882 where the entity referenced is not known until
6883 instantiation time. */
6885 ctx = DECL_CONTEXT (t);
6886 if (DECL_CLASS_SCOPE_P (t))
6888 ctx = tsubst_aggr_type (ctx, args,
6890 in_decl, /*entering_scope=*/1);
6891 /* If CTX is unchanged, then T is in fact the
6892 specialization we want. That situation occurs when
6893 referencing a static data member within in its own
6894 class. We can use pointer equality, rather than
6895 same_type_p, because DECL_CONTEXT is always
6897 if (ctx == DECL_CONTEXT (t))
6903 tmpl = DECL_TI_TEMPLATE (t);
6904 gen_tmpl = most_general_template (tmpl);
6905 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6906 spec = (retrieve_specialization
6908 /*class_specializations_p=*/false));
6913 /* A local variable. */
6915 /* Subsequent calls to pushdecl will fill this in. */
6917 spec = retrieve_local_specialization (t);
6919 /* If we already have the specialization we need, there is
6920 nothing more to do. */
6927 /* Create a new node for the specialization we need. */
6929 if (TREE_CODE (r) == VAR_DECL)
6931 /* Even if the original location is out of scope, the
6932 newly substituted one is not. */
6933 DECL_DEAD_FOR_LOCAL (r) = 0;
6934 DECL_INITIALIZED_P (r) = 0;
6935 DECL_TEMPLATE_INSTANTIATED (r) = 0;
6936 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6937 if (type == error_mark_node)
6938 return error_mark_node;
6939 type = complete_type (type);
6940 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6941 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6942 type = check_var_type (DECL_NAME (r), type);
6944 if (DECL_HAS_VALUE_EXPR_P (t))
6946 tree ve = DECL_VALUE_EXPR (t);
6947 ve = tsubst_expr (ve, args, complain, in_decl,
6948 /*constant_expression_p=*/false);
6949 SET_DECL_VALUE_EXPR (r, ve);
6952 else if (DECL_SELF_REFERENCE_P (t))
6953 SET_DECL_SELF_REFERENCE_P (r);
6954 TREE_TYPE (r) = type;
6955 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6956 DECL_CONTEXT (r) = ctx;
6957 /* Clear out the mangled name and RTL for the instantiation. */
6958 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6959 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
6960 SET_DECL_RTL (r, NULL_RTX);
6961 /* The initializer must not be expanded until it is required;
6963 DECL_INITIAL (r) = NULL_TREE;
6964 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
6965 SET_DECL_RTL (r, NULL_RTX);
6966 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
6967 if (TREE_CODE (r) == VAR_DECL)
6969 /* Possibly limit visibility based on template args. */
6970 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
6971 if (DECL_VISIBILITY_SPECIFIED (t))
6973 DECL_VISIBILITY_SPECIFIED (r) = 0;
6975 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
6977 determine_visibility (r);
6982 /* A static data member declaration is always marked
6983 external when it is declared in-class, even if an
6984 initializer is present. We mimic the non-template
6986 DECL_EXTERNAL (r) = 1;
6988 register_specialization (r, gen_tmpl, argvec, false);
6989 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
6990 SET_DECL_IMPLICIT_INSTANTIATION (r);
6993 register_local_specialization (r, t);
6995 TREE_CHAIN (r) = NULL_TREE;
7004 /* Restore the file and line information. */
7005 input_location = saved_loc;
7010 /* Substitute into the ARG_TYPES of a function type. */
7013 tsubst_arg_types (tree arg_types,
7015 tsubst_flags_t complain,
7018 tree remaining_arg_types;
7021 tree result = NULL_TREE;
7023 if (!arg_types || arg_types == void_list_node)
7026 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
7027 args, complain, in_decl);
7028 if (remaining_arg_types == error_mark_node)
7029 return error_mark_node;
7031 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
7032 if (type == error_mark_node)
7033 return error_mark_node;
7034 if (VOID_TYPE_P (type))
7036 if (complain & tf_error)
7038 error ("invalid parameter type %qT", type);
7040 error ("in declaration %q+D", in_decl);
7042 return error_mark_node;
7045 /* Do array-to-pointer, function-to-pointer conversion, and ignore
7046 top-level qualifiers as required. */
7047 type = TYPE_MAIN_VARIANT (type_decays_to (type));
7049 /* We do not substitute into default arguments here. The standard
7050 mandates that they be instantiated only when needed, which is
7051 done in build_over_call. */
7052 default_arg = TREE_PURPOSE (arg_types);
7054 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
7056 /* We've instantiated a template before its default arguments
7057 have been parsed. This can happen for a nested template
7058 class, and is not an error unless we require the default
7059 argument in a call of this function. */
7060 result = tree_cons (default_arg, type, remaining_arg_types);
7061 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result);
7064 result = hash_tree_cons (default_arg, type, remaining_arg_types);
7069 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
7070 *not* handle the exception-specification for FNTYPE, because the
7071 initial substitution of explicitly provided template parameters
7072 during argument deduction forbids substitution into the
7073 exception-specification:
7077 All references in the function type of the function template to the
7078 corresponding template parameters are replaced by the specified tem-
7079 plate argument values. If a substitution in a template parameter or
7080 in the function type of the function template results in an invalid
7081 type, type deduction fails. [Note: The equivalent substitution in
7082 exception specifications is done only when the function is instanti-
7083 ated, at which point a program is ill-formed if the substitution
7084 results in an invalid type.] */
7087 tsubst_function_type (tree t,
7089 tsubst_flags_t complain,
7096 /* The TYPE_CONTEXT is not used for function/method types. */
7097 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
7099 /* Substitute the return type. */
7100 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7101 if (return_type == error_mark_node)
7102 return error_mark_node;
7103 /* The standard does not presently indicate that creation of a
7104 function type with an invalid return type is a deduction failure.
7105 However, that is clearly analogous to creating an array of "void"
7106 or a reference to a reference. This is core issue #486. */
7107 if (TREE_CODE (return_type) == ARRAY_TYPE
7108 || TREE_CODE (return_type) == FUNCTION_TYPE)
7110 if (complain & tf_error)
7112 if (TREE_CODE (return_type) == ARRAY_TYPE)
7113 error ("function returning an array");
7115 error ("function returning a function");
7117 return error_mark_node;
7120 /* Substitute the argument types. */
7121 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
7123 if (arg_types == error_mark_node)
7124 return error_mark_node;
7126 /* Construct a new type node and return it. */
7127 if (TREE_CODE (t) == FUNCTION_TYPE)
7128 fntype = build_function_type (return_type, arg_types);
7131 tree r = TREE_TYPE (TREE_VALUE (arg_types));
7132 if (! IS_AGGR_TYPE (r))
7136 Type deduction may fail for any of the following
7139 -- Attempting to create "pointer to member of T" when T
7140 is not a class type. */
7141 if (complain & tf_error)
7142 error ("creating pointer to member function of non-class type %qT",
7144 return error_mark_node;
7147 fntype = build_method_type_directly (r, return_type,
7148 TREE_CHAIN (arg_types));
7150 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
7151 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
7156 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
7157 ARGS into that specification, and return the substituted
7158 specification. If there is no specification, return NULL_TREE. */
7161 tsubst_exception_specification (tree fntype,
7163 tsubst_flags_t complain,
7169 specs = TYPE_RAISES_EXCEPTIONS (fntype);
7170 new_specs = NULL_TREE;
7173 if (! TREE_VALUE (specs))
7179 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
7180 if (spec == error_mark_node)
7182 new_specs = add_exception_specifier (new_specs, spec, complain);
7183 specs = TREE_CHAIN (specs);
7189 /* Take the tree structure T and replace template parameters used
7190 therein with the argument vector ARGS. IN_DECL is an associated
7191 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
7192 Issue error and warning messages under control of COMPLAIN. Note
7193 that we must be relatively non-tolerant of extensions here, in
7194 order to preserve conformance; if we allow substitutions that
7195 should not be allowed, we may allow argument deductions that should
7196 not succeed, and therefore report ambiguous overload situations
7197 where there are none. In theory, we could allow the substitution,
7198 but indicate that it should have failed, and allow our caller to
7199 make sure that the right thing happens, but we don't try to do this
7202 This function is used for dealing with types, decls and the like;
7203 for expressions, use tsubst_expr or tsubst_copy. */
7206 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7210 if (t == NULL_TREE || t == error_mark_node
7211 || t == integer_type_node
7212 || t == void_type_node
7213 || t == char_type_node
7214 || t == unknown_type_node
7215 || TREE_CODE (t) == NAMESPACE_DECL)
7219 return tsubst_decl (t, args, complain);
7221 if (TREE_CODE (t) == IDENTIFIER_NODE)
7222 type = IDENTIFIER_TYPE_VALUE (t);
7224 type = TREE_TYPE (t);
7226 gcc_assert (type != unknown_type_node);
7229 && TREE_CODE (t) != TYPENAME_TYPE
7230 && TREE_CODE (t) != IDENTIFIER_NODE
7231 && TREE_CODE (t) != FUNCTION_TYPE
7232 && TREE_CODE (t) != METHOD_TYPE)
7233 type = tsubst (type, args, complain, in_decl);
7234 if (type == error_mark_node)
7235 return error_mark_node;
7237 switch (TREE_CODE (t))
7242 return tsubst_aggr_type (t, args, complain, in_decl,
7243 /*entering_scope=*/0);
7246 case IDENTIFIER_NODE:
7258 if (t == integer_type_node)
7261 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
7262 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
7266 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
7268 max = tsubst_expr (omax, args, complain, in_decl,
7269 /*integral_constant_expression_p=*/false);
7270 max = fold_decl_constant_value (max);
7272 if (TREE_CODE (max) != INTEGER_CST
7273 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
7274 && !at_function_scope_p ())
7276 if (complain & tf_error)
7277 error ("array bound is not an integer constant");
7278 return error_mark_node;
7283 Type deduction may fail for any of the following
7286 Attempting to create an array with a size that is
7287 zero or negative. */
7288 if (integer_zerop (max) && !(complain & tf_error))
7289 /* We must fail if performing argument deduction (as
7290 indicated by the state of complain), so that
7291 another substitution can be found. */
7292 return error_mark_node;
7293 else if (TREE_CODE (max) == INTEGER_CST
7294 && INT_CST_LT (max, integer_zero_node))
7296 if (complain & tf_error)
7297 error ("creating array with negative size (%qE)", max);
7299 return error_mark_node;
7302 return compute_array_index_type (NULL_TREE, max);
7305 case TEMPLATE_TYPE_PARM:
7306 case TEMPLATE_TEMPLATE_PARM:
7307 case BOUND_TEMPLATE_TEMPLATE_PARM:
7308 case TEMPLATE_PARM_INDEX:
7313 tree arg = NULL_TREE;
7317 gcc_assert (TREE_VEC_LENGTH (args) > 0);
7318 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7319 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
7320 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7322 idx = TEMPLATE_TYPE_IDX (t);
7323 level = TEMPLATE_TYPE_LEVEL (t);
7327 idx = TEMPLATE_PARM_IDX (t);
7328 level = TEMPLATE_PARM_LEVEL (t);
7331 levels = TMPL_ARGS_DEPTH (args);
7332 if (level <= levels)
7333 arg = TMPL_ARG (args, level, idx);
7335 if (arg == error_mark_node)
7336 return error_mark_node;
7337 else if (arg != NULL_TREE)
7339 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
7342 gcc_assert (TYPE_P (arg));
7344 /* cv-quals from the template are discarded when
7345 substituting in a function or reference type. */
7346 if (TREE_CODE (arg) == FUNCTION_TYPE
7347 || TREE_CODE (arg) == METHOD_TYPE
7348 || TREE_CODE (arg) == REFERENCE_TYPE)
7349 quals = cp_type_quals (arg);
7351 quals = cp_type_quals (arg) | cp_type_quals (t);
7353 return cp_build_qualified_type_real
7354 (arg, quals, complain | tf_ignore_bad_quals);
7356 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7358 /* We are processing a type constructed from a
7359 template template parameter. */
7360 tree argvec = tsubst (TYPE_TI_ARGS (t),
7361 args, complain, in_decl);
7362 if (argvec == error_mark_node)
7363 return error_mark_node;
7365 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
7366 are resolving nested-types in the signature of a
7367 member function templates. Otherwise ARG is a
7368 TEMPLATE_DECL and is the real template to be
7370 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
7371 arg = TYPE_NAME (arg);
7373 r = lookup_template_class (arg,
7376 /*entering_scope=*/0,
7378 return cp_build_qualified_type_real
7379 (r, TYPE_QUALS (t), complain);
7382 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
7387 /* This can happen during the attempted tsubst'ing in
7388 unify. This means that we don't yet have any information
7389 about the template parameter in question. */
7392 /* If we get here, we must have been looking at a parm for a
7393 more deeply nested template. Make a new version of this
7394 template parameter, but with a lower level. */
7395 switch (TREE_CODE (t))
7397 case TEMPLATE_TYPE_PARM:
7398 case TEMPLATE_TEMPLATE_PARM:
7399 case BOUND_TEMPLATE_TEMPLATE_PARM:
7400 if (cp_type_quals (t))
7402 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
7403 r = cp_build_qualified_type_real
7404 (r, cp_type_quals (t),
7405 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7406 ? tf_ignore_bad_quals : 0));
7411 TEMPLATE_TYPE_PARM_INDEX (r)
7412 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
7414 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
7415 TYPE_MAIN_VARIANT (r) = r;
7416 TYPE_POINTER_TO (r) = NULL_TREE;
7417 TYPE_REFERENCE_TO (r) = NULL_TREE;
7419 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7421 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
7423 if (argvec == error_mark_node)
7424 return error_mark_node;
7426 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
7427 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
7432 case TEMPLATE_PARM_INDEX:
7433 r = reduce_template_parm_level (t, type, levels);
7445 tree purpose, value, chain;
7447 if (t == void_list_node)
7450 purpose = TREE_PURPOSE (t);
7453 purpose = tsubst (purpose, args, complain, in_decl);
7454 if (purpose == error_mark_node)
7455 return error_mark_node;
7457 value = TREE_VALUE (t);
7460 value = tsubst (value, args, complain, in_decl);
7461 if (value == error_mark_node)
7462 return error_mark_node;
7464 chain = TREE_CHAIN (t);
7465 if (chain && chain != void_type_node)
7467 chain = tsubst (chain, args, complain, in_decl);
7468 if (chain == error_mark_node)
7469 return error_mark_node;
7471 if (purpose == TREE_PURPOSE (t)
7472 && value == TREE_VALUE (t)
7473 && chain == TREE_CHAIN (t))
7475 return hash_tree_cons (purpose, value, chain);
7479 /* We should never be tsubsting a binfo. */
7483 /* A vector of template arguments. */
7485 return tsubst_template_args (t, args, complain, in_decl);
7488 case REFERENCE_TYPE:
7490 enum tree_code code;
7492 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
7495 code = TREE_CODE (t);
7500 Type deduction may fail for any of the following
7503 -- Attempting to create a pointer to reference type.
7504 -- Attempting to create a reference to a reference type or
7505 a reference to void. */
7506 if (TREE_CODE (type) == REFERENCE_TYPE
7507 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
7509 static location_t last_loc;
7511 /* We keep track of the last time we issued this error
7512 message to avoid spewing a ton of messages during a
7513 single bad template instantiation. */
7514 if (complain & tf_error
7515 #ifdef USE_MAPPED_LOCATION
7516 && last_loc != input_location
7518 && (last_loc.line != input_line
7519 || last_loc.file != input_filename)
7523 if (TREE_CODE (type) == VOID_TYPE)
7524 error ("forming reference to void");
7526 error ("forming %s to reference type %qT",
7527 (code == POINTER_TYPE) ? "pointer" : "reference",
7529 last_loc = input_location;
7532 return error_mark_node;
7534 else if (code == POINTER_TYPE)
7536 r = build_pointer_type (type);
7537 if (TREE_CODE (type) == METHOD_TYPE)
7538 r = build_ptrmemfunc_type (r);
7541 r = build_reference_type (type);
7542 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7544 if (r != error_mark_node)
7545 /* Will this ever be needed for TYPE_..._TO values? */
7552 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7553 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7557 Type deduction may fail for any of the following
7560 -- Attempting to create "pointer to member of T" when T
7561 is not a class type. */
7562 if (complain & tf_error)
7563 error ("creating pointer to member of non-class type %qT", r);
7564 return error_mark_node;
7566 if (TREE_CODE (type) == REFERENCE_TYPE)
7568 if (complain & tf_error)
7569 error ("creating pointer to member reference type %qT", type);
7570 return error_mark_node;
7572 if (TREE_CODE (type) == VOID_TYPE)
7574 if (complain & tf_error)
7575 error ("creating pointer to member of type void");
7576 return error_mark_node;
7578 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
7579 if (TREE_CODE (type) == FUNCTION_TYPE)
7581 /* The type of the implicit object parameter gets its
7582 cv-qualifiers from the FUNCTION_TYPE. */
7584 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
7585 cp_type_quals (type));
7587 method_type = build_method_type_directly (this_type,
7589 TYPE_ARG_TYPES (type));
7590 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
7591 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
7595 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7604 fntype = tsubst_function_type (t, args, complain, in_decl);
7605 if (fntype == error_mark_node)
7606 return error_mark_node;
7608 /* Substitute the exception specification. */
7609 specs = tsubst_exception_specification (t, args, complain,
7611 if (specs == error_mark_node)
7612 return error_mark_node;
7614 fntype = build_exception_variant (fntype, specs);
7619 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7620 if (domain == error_mark_node)
7621 return error_mark_node;
7623 /* As an optimization, we avoid regenerating the array type if
7624 it will obviously be the same as T. */
7625 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7628 /* These checks should match the ones in grokdeclarator.
7632 The deduction may fail for any of the following reasons:
7634 -- Attempting to create an array with an element type that
7635 is void, a function type, or a reference type, or [DR337]
7636 an abstract class type. */
7637 if (TREE_CODE (type) == VOID_TYPE
7638 || TREE_CODE (type) == FUNCTION_TYPE
7639 || TREE_CODE (type) == REFERENCE_TYPE)
7641 if (complain & tf_error)
7642 error ("creating array of %qT", type);
7643 return error_mark_node;
7645 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7647 if (complain & tf_error)
7648 error ("creating array of %qT, which is an abstract class type",
7650 return error_mark_node;
7653 r = build_cplus_array_type (type, domain);
7660 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7661 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7663 if (e1 == error_mark_node || e2 == error_mark_node)
7664 return error_mark_node;
7666 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
7672 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7673 if (e == error_mark_node)
7674 return error_mark_node;
7676 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
7681 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7682 in_decl, /*entering_scope=*/1);
7683 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7686 if (ctx == error_mark_node || f == error_mark_node)
7687 return error_mark_node;
7689 if (!IS_AGGR_TYPE (ctx))
7691 if (complain & tf_error)
7692 error ("%qT is not a class, struct, or union type", ctx);
7693 return error_mark_node;
7695 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7697 /* Normally, make_typename_type does not require that the CTX
7698 have complete type in order to allow things like:
7700 template <class T> struct S { typename S<T>::X Y; };
7702 But, such constructs have already been resolved by this
7703 point, so here CTX really should have complete type, unless
7704 it's a partial instantiation. */
7705 ctx = complete_type (ctx);
7706 if (!COMPLETE_TYPE_P (ctx))
7708 if (complain & tf_error)
7709 cxx_incomplete_type_error (NULL_TREE, ctx);
7710 return error_mark_node;
7714 f = make_typename_type (ctx, f, typename_type,
7715 (complain & tf_error) | tf_keep_type_decl);
7716 if (f == error_mark_node)
7718 if (TREE_CODE (f) == TYPE_DECL)
7720 complain |= tf_ignore_bad_quals;
7724 if (TREE_CODE (f) != TYPENAME_TYPE)
7726 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
7727 error ("%qT resolves to %qT, which is not an enumeration type",
7729 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
7730 error ("%qT resolves to %qT, which is is not a class type",
7734 return cp_build_qualified_type_real
7735 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7738 case UNBOUND_CLASS_TEMPLATE:
7740 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7741 in_decl, /*entering_scope=*/1);
7742 tree name = TYPE_IDENTIFIER (t);
7743 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
7745 if (ctx == error_mark_node || name == error_mark_node)
7746 return error_mark_node;
7749 parm_list = tsubst_template_parms (parm_list, args, complain);
7750 return make_unbound_class_template (ctx, name, parm_list, complain);
7760 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7761 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
7762 /*integral_constant_expression_p=*/false);
7763 if (e1 == error_mark_node || e2 == error_mark_node)
7764 return error_mark_node;
7766 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
7771 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7772 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7773 if (e1 == error_mark_node || e2 == error_mark_node)
7774 return error_mark_node;
7776 return build_qualified_name (/*type=*/NULL_TREE,
7777 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
7784 type = finish_typeof (tsubst_expr
7785 (TYPEOF_TYPE_EXPR (t), args,
7787 /*integral_constant_expression_p=*/false));
7788 return cp_build_qualified_type_real (type,
7790 | cp_type_quals (type),
7795 sorry ("use of %qs in template",
7796 tree_code_name [(int) TREE_CODE (t)]);
7797 return error_mark_node;
7801 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7802 type of the expression on the left-hand side of the "." or "->"
7806 tsubst_baselink (tree baselink, tree object_type,
7807 tree args, tsubst_flags_t complain, tree in_decl)
7810 tree qualifying_scope;
7813 tree template_args = 0;
7814 bool template_id_p = false;
7816 /* A baselink indicates a function from a base class. Both the
7817 BASELINK_ACCESS_BINFO and the base class referenced may
7818 indicate bases of the template class, rather than the
7819 instantiated class. In addition, lookups that were not
7820 ambiguous before may be ambiguous now. Therefore, we perform
7821 the lookup again. */
7822 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7823 qualifying_scope = tsubst (qualifying_scope, args,
7825 fns = BASELINK_FUNCTIONS (baselink);
7826 optype = BASELINK_OPTYPE (baselink);
7827 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7829 template_id_p = true;
7830 template_args = TREE_OPERAND (fns, 1);
7831 fns = TREE_OPERAND (fns, 0);
7833 template_args = tsubst_template_args (template_args, args,
7836 name = DECL_NAME (get_first_fn (fns));
7837 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7839 /* If lookup found a single function, mark it as used at this
7840 point. (If it lookup found multiple functions the one selected
7841 later by overload resolution will be marked as used at that
7843 if (BASELINK_P (baselink))
7844 fns = BASELINK_FUNCTIONS (baselink);
7845 if (!template_id_p && !really_overloaded_fn (fns))
7846 mark_used (OVL_CURRENT (fns));
7848 /* Add back the template arguments, if present. */
7849 if (BASELINK_P (baselink) && template_id_p)
7850 BASELINK_FUNCTIONS (baselink)
7851 = build_nt (TEMPLATE_ID_EXPR,
7852 BASELINK_FUNCTIONS (baselink),
7854 /* Update the conversion operator type. */
7855 BASELINK_OPTYPE (baselink)
7856 = tsubst (optype, args, complain, in_decl);
7859 object_type = current_class_type;
7860 return adjust_result_of_qualified_name_lookup (baselink,
7865 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7866 true if the qualified-id will be a postfix-expression in-and-of
7867 itself; false if more of the postfix-expression follows the
7868 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7872 tsubst_qualified_id (tree qualified_id, tree args,
7873 tsubst_flags_t complain, tree in_decl,
7874 bool done, bool address_p)
7882 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
7884 /* Figure out what name to look up. */
7885 name = TREE_OPERAND (qualified_id, 1);
7886 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7889 template_args = TREE_OPERAND (name, 1);
7891 template_args = tsubst_template_args (template_args, args,
7893 name = TREE_OPERAND (name, 0);
7897 is_template = false;
7898 template_args = NULL_TREE;
7901 /* Substitute into the qualifying scope. When there are no ARGS, we
7902 are just trying to simplify a non-dependent expression. In that
7903 case the qualifying scope may be dependent, and, in any case,
7904 substituting will not help. */
7905 scope = TREE_OPERAND (qualified_id, 0);
7908 scope = tsubst (scope, args, complain, in_decl);
7909 expr = tsubst_copy (name, args, complain, in_decl);
7914 if (dependent_type_p (scope))
7915 return build_qualified_name (/*type=*/NULL_TREE,
7917 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
7919 if (!BASELINK_P (name) && !DECL_P (expr))
7921 if (TREE_CODE (expr) == BIT_NOT_EXPR)
7922 /* If this were actually a destructor call, it would have been
7923 parsed as such by the parser. */
7924 expr = error_mark_node;
7926 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7927 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7928 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7930 if (complain & tf_error)
7932 error ("dependent-name %qE is parsed as a non-type, but "
7933 "instantiation yields a type", qualified_id);
7934 inform ("say %<typename %E%> if a type is meant", qualified_id);
7936 return error_mark_node;
7942 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7944 /* Remember that there was a reference to this entity. */
7948 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
7950 if (complain & tf_error)
7951 qualified_name_lookup_error (scope,
7952 TREE_OPERAND (qualified_id, 1),
7954 return error_mark_node;
7958 expr = lookup_template_function (expr, template_args);
7960 if (expr == error_mark_node && complain & tf_error)
7961 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
7963 else if (TYPE_P (scope))
7965 expr = (adjust_result_of_qualified_name_lookup
7966 (expr, scope, current_class_type));
7967 expr = (finish_qualified_id_expr
7968 (scope, expr, done, address_p,
7969 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
7970 /*template_arg_p=*/false));
7973 /* Expressions do not generally have reference type. */
7974 if (TREE_CODE (expr) != SCOPE_REF
7975 /* However, if we're about to form a pointer-to-member, we just
7976 want the referenced member referenced. */
7977 && TREE_CODE (expr) != OFFSET_REF)
7978 expr = convert_from_reference (expr);
7983 /* Like tsubst, but deals with expressions. This function just replaces
7984 template parms; to finish processing the resultant expression, use
7988 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7990 enum tree_code code;
7993 if (t == NULL_TREE || t == error_mark_node)
7996 code = TREE_CODE (t);
8001 r = retrieve_local_specialization (t);
8002 gcc_assert (r != NULL);
8011 if (DECL_TEMPLATE_PARM_P (t))
8012 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
8013 /* There is no need to substitute into namespace-scope
8015 if (DECL_NAMESPACE_SCOPE_P (t))
8017 /* If ARGS is NULL, then T is known to be non-dependent. */
8018 if (args == NULL_TREE)
8019 return integral_constant_value (t);
8021 /* Unfortunately, we cannot just call lookup_name here.
8024 template <int I> int f() {
8026 struct S { void g() { E e = a; } };
8029 When we instantiate f<7>::S::g(), say, lookup_name is not
8030 clever enough to find f<7>::a. */
8032 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
8033 /*entering_scope=*/0);
8035 for (v = TYPE_VALUES (enum_type);
8038 if (TREE_PURPOSE (v) == DECL_NAME (t))
8039 return TREE_VALUE (v);
8041 /* We didn't find the name. That should never happen; if
8042 name-lookup found it during preliminary parsing, we
8043 should find it again here during instantiation. */
8049 if (DECL_CONTEXT (t))
8053 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
8054 /*entering_scope=*/1);
8055 if (ctx != DECL_CONTEXT (t))
8057 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
8060 if (complain & tf_error)
8061 error ("using invalid field %qD", t);
8062 return error_mark_node;
8072 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
8073 || local_variable_p (t))
8074 t = tsubst (t, args, complain, in_decl);
8079 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
8082 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8083 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
8084 args, complain, in_decl);
8085 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
8086 return tsubst (t, args, complain, in_decl);
8087 else if (DECL_CLASS_SCOPE_P (t)
8088 && uses_template_parms (DECL_CONTEXT (t)))
8090 /* Template template argument like the following example need
8093 template <template <class> class TT> struct C {};
8094 template <class T> struct D {
8095 template <class U> struct E {};
8100 We are processing the template argument `E' in #1 for
8101 the template instantiation #2. Originally, `E' is a
8102 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
8103 have to substitute this with one having context `D<int>'. */
8105 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
8106 return lookup_field (context, DECL_NAME(t), 0, false);
8109 /* Ordinary template template argument. */
8113 case REINTERPRET_CAST_EXPR:
8114 case CONST_CAST_EXPR:
8115 case STATIC_CAST_EXPR:
8116 case DYNAMIC_CAST_EXPR:
8119 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8120 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8124 case TRUTH_NOT_EXPR:
8127 case UNARY_PLUS_EXPR: /* Unary + */
8136 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8137 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8144 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
8145 name = TREE_OPERAND (t, 1);
8146 if (TREE_CODE (name) == BIT_NOT_EXPR)
8148 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8150 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8152 else if (TREE_CODE (name) == SCOPE_REF
8153 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
8155 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
8157 name = TREE_OPERAND (name, 1);
8158 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8160 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8161 name = build_qualified_name (/*type=*/NULL_TREE,
8163 /*template_p=*/false);
8165 else if (TREE_CODE (name) == BASELINK)
8166 name = tsubst_baselink (name,
8167 non_reference (TREE_TYPE (object)),
8171 name = tsubst_copy (name, args, complain, in_decl);
8172 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
8178 case TRUNC_DIV_EXPR:
8180 case FLOOR_DIV_EXPR:
8181 case ROUND_DIV_EXPR:
8182 case EXACT_DIV_EXPR:
8186 case TRUNC_MOD_EXPR:
8187 case FLOOR_MOD_EXPR:
8188 case TRUTH_ANDIF_EXPR:
8189 case TRUTH_ORIF_EXPR:
8190 case TRUTH_AND_EXPR:
8207 case PREDECREMENT_EXPR:
8208 case PREINCREMENT_EXPR:
8209 case POSTDECREMENT_EXPR:
8210 case POSTINCREMENT_EXPR:
8212 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8213 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8216 return build_qualified_name (/*type=*/NULL_TREE,
8217 tsubst_copy (TREE_OPERAND (t, 0),
8218 args, complain, in_decl),
8219 tsubst_copy (TREE_OPERAND (t, 1),
8220 args, complain, in_decl),
8221 QUALIFIED_NAME_IS_TEMPLATE (t));
8226 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8227 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8228 NULL_TREE, NULL_TREE);
8231 return build_nt (code,
8232 tsubst_copy (TREE_OPERAND (t, 0), args,
8234 tsubst_copy (TREE_OPERAND (t, 1), args, complain,
8240 case PSEUDO_DTOR_EXPR:
8243 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8244 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8245 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8246 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
8253 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8254 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8255 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8256 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
8263 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8264 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8265 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
8266 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
8270 case TEMPLATE_ID_EXPR:
8272 /* Substituted template arguments */
8273 tree fn = TREE_OPERAND (t, 0);
8274 tree targs = TREE_OPERAND (t, 1);
8276 fn = tsubst_copy (fn, args, complain, in_decl);
8278 targs = tsubst_template_args (targs, args, complain, in_decl);
8280 return lookup_template_function (fn, targs);
8285 tree purpose, value, chain;
8287 if (t == void_list_node)
8290 purpose = TREE_PURPOSE (t);
8292 purpose = tsubst_copy (purpose, args, complain, in_decl);
8293 value = TREE_VALUE (t);
8295 value = tsubst_copy (value, args, complain, in_decl);
8296 chain = TREE_CHAIN (t);
8297 if (chain && chain != void_type_node)
8298 chain = tsubst_copy (chain, args, complain, in_decl);
8299 if (purpose == TREE_PURPOSE (t)
8300 && value == TREE_VALUE (t)
8301 && chain == TREE_CHAIN (t))
8303 return tree_cons (purpose, value, chain);
8310 case TEMPLATE_TYPE_PARM:
8311 case TEMPLATE_TEMPLATE_PARM:
8312 case BOUND_TEMPLATE_TEMPLATE_PARM:
8313 case TEMPLATE_PARM_INDEX:
8315 case REFERENCE_TYPE:
8321 case UNBOUND_CLASS_TEMPLATE:
8324 return tsubst (t, args, complain, in_decl);
8326 case IDENTIFIER_NODE:
8327 if (IDENTIFIER_TYPENAME_P (t))
8329 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8330 return mangle_conv_op_name_for_type (new_type);
8336 /* This is handled by tsubst_copy_and_build. */
8340 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
8342 tsubst (TREE_TYPE (t), args, complain, in_decl));
8344 case CLEANUP_POINT_EXPR:
8345 /* We shouldn't have built any of these during initial template
8346 generation. Instead, they should be built during instantiation
8347 in response to the saved STMT_IS_FULL_EXPR_P setting. */
8351 mark_used (TREE_OPERAND (t, 1));
8359 /* Like tsubst_copy, but specifically for OpenMP clauses. */
8362 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
8365 tree new_clauses = NULL, nc, oc;
8367 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
8369 nc = copy_node (oc);
8370 OMP_CLAUSE_CHAIN (nc) = new_clauses;
8373 switch (OMP_CLAUSE_CODE (nc))
8375 case OMP_CLAUSE_PRIVATE:
8376 case OMP_CLAUSE_SHARED:
8377 case OMP_CLAUSE_FIRSTPRIVATE:
8378 case OMP_CLAUSE_LASTPRIVATE:
8379 case OMP_CLAUSE_REDUCTION:
8380 case OMP_CLAUSE_COPYIN:
8381 case OMP_CLAUSE_COPYPRIVATE:
8383 case OMP_CLAUSE_NUM_THREADS:
8384 case OMP_CLAUSE_SCHEDULE:
8385 OMP_CLAUSE_OPERAND (nc, 0)
8386 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
8387 in_decl, /*integral_constant_expression_p=*/false);
8389 case OMP_CLAUSE_NOWAIT:
8390 case OMP_CLAUSE_ORDERED:
8391 case OMP_CLAUSE_DEFAULT:
8398 return finish_omp_clauses (nreverse (new_clauses));
8401 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
8404 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
8407 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
8409 tree purpose, value, chain;
8414 if (TREE_CODE (t) != TREE_LIST)
8415 return tsubst_copy_and_build (t, args, complain, in_decl,
8416 /*function_p=*/false,
8417 /*integral_constant_expression_p=*/false);
8419 if (t == void_list_node)
8422 purpose = TREE_PURPOSE (t);
8424 purpose = RECUR (purpose);
8425 value = TREE_VALUE (t);
8427 value = RECUR (value);
8428 chain = TREE_CHAIN (t);
8429 if (chain && chain != void_type_node)
8430 chain = RECUR (chain);
8431 return tree_cons (purpose, value, chain);
8435 /* Like tsubst_copy for expressions, etc. but also does semantic
8439 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
8440 bool integral_constant_expression_p)
8442 #define RECUR(NODE) \
8443 tsubst_expr ((NODE), args, complain, in_decl, \
8444 integral_constant_expression_p)
8448 if (t == NULL_TREE || t == error_mark_node)
8451 if (EXPR_HAS_LOCATION (t))
8452 input_location = EXPR_LOCATION (t);
8453 if (STATEMENT_CODE_P (TREE_CODE (t)))
8454 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
8456 switch (TREE_CODE (t))
8458 case STATEMENT_LIST:
8460 tree_stmt_iterator i;
8461 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
8462 RECUR (tsi_stmt (i));
8466 case CTOR_INITIALIZER:
8467 finish_mem_initializers (tsubst_initializer_list
8468 (TREE_OPERAND (t, 0), args));
8472 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
8476 tmp = RECUR (EXPR_STMT_EXPR (t));
8477 if (EXPR_STMT_STMT_EXPR_RESULT (t))
8478 finish_stmt_expr_expr (tmp, cur_stmt_expr);
8480 finish_expr_stmt (tmp);
8484 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
8492 decl = DECL_EXPR_DECL (t);
8493 if (TREE_CODE (decl) == LABEL_DECL)
8494 finish_label_decl (DECL_NAME (decl));
8495 else if (TREE_CODE (decl) == USING_DECL)
8497 tree scope = USING_DECL_SCOPE (decl);
8498 tree name = DECL_NAME (decl);
8501 scope = RECUR (scope);
8502 decl = lookup_qualified_name (scope, name,
8503 /*is_type_p=*/false,
8504 /*complain=*/false);
8505 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
8506 qualified_name_lookup_error (scope, name, decl);
8508 do_local_using_decl (decl, scope, name);
8512 init = DECL_INITIAL (decl);
8513 decl = tsubst (decl, args, complain, in_decl);
8514 if (decl != error_mark_node)
8516 /* By marking the declaration as instantiated, we avoid
8517 trying to instantiate it. Since instantiate_decl can't
8518 handle local variables, and since we've already done
8519 all that needs to be done, that's the right thing to
8521 if (TREE_CODE (decl) == VAR_DECL)
8522 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8523 if (TREE_CODE (decl) == VAR_DECL
8524 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
8525 /* Anonymous aggregates are a special case. */
8526 finish_anon_union (decl);
8529 maybe_push_decl (decl);
8530 if (TREE_CODE (decl) == VAR_DECL
8531 && DECL_PRETTY_FUNCTION_P (decl))
8533 /* For __PRETTY_FUNCTION__ we have to adjust the
8535 const char *const name
8536 = cxx_printable_name (current_function_decl, 2);
8537 init = cp_fname_init (name, &TREE_TYPE (decl));
8540 init = RECUR (init);
8541 finish_decl (decl, init, NULL_TREE);
8546 /* A DECL_EXPR can also be used as an expression, in the condition
8547 clause of an if/for/while construct. */
8552 stmt = begin_for_stmt ();
8553 RECUR (FOR_INIT_STMT (t));
8554 finish_for_init_stmt (stmt);
8555 tmp = RECUR (FOR_COND (t));
8556 finish_for_cond (tmp, stmt);
8557 tmp = RECUR (FOR_EXPR (t));
8558 finish_for_expr (tmp, stmt);
8559 RECUR (FOR_BODY (t));
8560 finish_for_stmt (stmt);
8564 stmt = begin_while_stmt ();
8565 tmp = RECUR (WHILE_COND (t));
8566 finish_while_stmt_cond (tmp, stmt);
8567 RECUR (WHILE_BODY (t));
8568 finish_while_stmt (stmt);
8572 stmt = begin_do_stmt ();
8573 RECUR (DO_BODY (t));
8574 finish_do_body (stmt);
8575 tmp = RECUR (DO_COND (t));
8576 finish_do_stmt (tmp, stmt);
8580 stmt = begin_if_stmt ();
8581 tmp = RECUR (IF_COND (t));
8582 finish_if_stmt_cond (tmp, stmt);
8583 RECUR (THEN_CLAUSE (t));
8584 finish_then_clause (stmt);
8586 if (ELSE_CLAUSE (t))
8588 begin_else_clause (stmt);
8589 RECUR (ELSE_CLAUSE (t));
8590 finish_else_clause (stmt);
8593 finish_if_stmt (stmt);
8597 if (BIND_EXPR_BODY_BLOCK (t))
8598 stmt = begin_function_body ();
8600 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
8601 ? BCS_TRY_BLOCK : 0);
8603 RECUR (BIND_EXPR_BODY (t));
8605 if (BIND_EXPR_BODY_BLOCK (t))
8606 finish_function_body (stmt);
8608 finish_compound_stmt (stmt);
8612 finish_break_stmt ();
8616 finish_continue_stmt ();
8620 stmt = begin_switch_stmt ();
8621 tmp = RECUR (SWITCH_STMT_COND (t));
8622 finish_switch_cond (tmp, stmt);
8623 RECUR (SWITCH_STMT_BODY (t));
8624 finish_switch_stmt (stmt);
8627 case CASE_LABEL_EXPR:
8628 finish_case_label (RECUR (CASE_LOW (t)),
8629 RECUR (CASE_HIGH (t)));
8633 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
8637 tmp = GOTO_DESTINATION (t);
8638 if (TREE_CODE (tmp) != LABEL_DECL)
8639 /* Computed goto's must be tsubst'd into. On the other hand,
8640 non-computed gotos must not be; the identifier in question
8641 will have no binding. */
8644 tmp = DECL_NAME (tmp);
8645 finish_goto_stmt (tmp);
8649 tmp = finish_asm_stmt
8650 (ASM_VOLATILE_P (t),
8651 RECUR (ASM_STRING (t)),
8652 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
8653 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
8654 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
8656 tree asm_expr = tmp;
8657 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
8658 asm_expr = TREE_OPERAND (asm_expr, 0);
8659 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
8666 stmt = begin_try_block ();
8667 RECUR (TRY_STMTS (t));
8668 finish_cleanup_try_block (stmt);
8669 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
8673 tree compound_stmt = NULL_TREE;
8675 if (FN_TRY_BLOCK_P (t))
8676 stmt = begin_function_try_block (&compound_stmt);
8678 stmt = begin_try_block ();
8680 RECUR (TRY_STMTS (t));
8682 if (FN_TRY_BLOCK_P (t))
8683 finish_function_try_block (stmt);
8685 finish_try_block (stmt);
8687 RECUR (TRY_HANDLERS (t));
8688 if (FN_TRY_BLOCK_P (t))
8689 finish_function_handler_sequence (stmt, compound_stmt);
8691 finish_handler_sequence (stmt);
8697 tree decl = HANDLER_PARMS (t);
8701 decl = tsubst (decl, args, complain, in_decl);
8702 /* Prevent instantiate_decl from trying to instantiate
8703 this variable. We've already done all that needs to be
8705 if (decl != error_mark_node)
8706 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8708 stmt = begin_handler ();
8709 finish_handler_parms (decl, stmt);
8710 RECUR (HANDLER_BODY (t));
8711 finish_handler (stmt);
8716 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8720 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
8721 args, complain, in_decl);
8722 stmt = begin_omp_parallel ();
8723 RECUR (OMP_PARALLEL_BODY (t));
8724 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
8725 = OMP_PARALLEL_COMBINED (t);
8730 tree clauses, decl, init, cond, incr, body, pre_body;
8732 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
8733 args, complain, in_decl);
8734 init = OMP_FOR_INIT (t);
8735 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
8736 decl = RECUR (TREE_OPERAND (init, 0));
8737 init = RECUR (TREE_OPERAND (init, 1));
8738 cond = RECUR (OMP_FOR_COND (t));
8739 incr = RECUR (OMP_FOR_INCR (t));
8741 stmt = begin_omp_structured_block ();
8743 pre_body = push_stmt_list ();
8744 RECUR (OMP_FOR_PRE_BODY (t));
8745 pre_body = pop_stmt_list (pre_body);
8747 body = push_stmt_list ();
8748 RECUR (OMP_FOR_BODY (t));
8749 body = pop_stmt_list (body);
8751 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
8754 OMP_FOR_CLAUSES (t) = clauses;
8756 add_stmt (finish_omp_structured_block (stmt));
8762 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
8763 stmt = push_stmt_list ();
8764 RECUR (OMP_BODY (t));
8765 stmt = pop_stmt_list (stmt);
8768 OMP_BODY (t) = stmt;
8769 OMP_CLAUSES (t) = tmp;
8777 stmt = push_stmt_list ();
8778 RECUR (OMP_BODY (t));
8779 stmt = pop_stmt_list (stmt);
8782 OMP_BODY (t) = stmt;
8789 op0 = RECUR (TREE_OPERAND (t, 0));
8790 op1 = RECUR (TREE_OPERAND (t, 1));
8791 finish_omp_atomic (OMP_ATOMIC_CODE (t), op0, op1);
8796 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
8798 return tsubst_copy_and_build (t, args, complain, in_decl,
8799 /*function_p=*/false,
8800 integral_constant_expression_p);
8807 /* T is a postfix-expression that is not being used in a function
8808 call. Return the substituted version of T. */
8811 tsubst_non_call_postfix_expression (tree t, tree args,
8812 tsubst_flags_t complain,
8815 if (TREE_CODE (t) == SCOPE_REF)
8816 t = tsubst_qualified_id (t, args, complain, in_decl,
8817 /*done=*/false, /*address_p=*/false);
8819 t = tsubst_copy_and_build (t, args, complain, in_decl,
8820 /*function_p=*/false,
8821 /*integral_constant_expression_p=*/false);
8826 /* Like tsubst but deals with expressions and performs semantic
8827 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8830 tsubst_copy_and_build (tree t,
8832 tsubst_flags_t complain,
8835 bool integral_constant_expression_p)
8837 #define RECUR(NODE) \
8838 tsubst_copy_and_build (NODE, args, complain, in_decl, \
8839 /*function_p=*/false, \
8840 integral_constant_expression_p)
8844 if (t == NULL_TREE || t == error_mark_node)
8847 switch (TREE_CODE (t))
8852 case IDENTIFIER_NODE:
8856 bool non_integral_constant_expression_p;
8857 const char *error_msg;
8859 if (IDENTIFIER_TYPENAME_P (t))
8861 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8862 t = mangle_conv_op_name_for_type (new_type);
8865 /* Look up the name. */
8866 decl = lookup_name (t);
8868 /* By convention, expressions use ERROR_MARK_NODE to indicate
8869 failure, not NULL_TREE. */
8870 if (decl == NULL_TREE)
8871 decl = error_mark_node;
8873 decl = finish_id_expression (t, decl, NULL_TREE,
8875 integral_constant_expression_p,
8876 /*allow_non_integral_constant_expression_p=*/false,
8877 &non_integral_constant_expression_p,
8878 /*template_p=*/false,
8880 /*address_p=*/false,
8881 /*template_arg_p=*/false,
8885 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8886 decl = unqualified_name_lookup_error (decl);
8890 case TEMPLATE_ID_EXPR:
8893 tree template = RECUR (TREE_OPERAND (t, 0));
8894 tree targs = TREE_OPERAND (t, 1);
8897 targs = tsubst_template_args (targs, args, complain, in_decl);
8899 if (TREE_CODE (template) == COMPONENT_REF)
8901 object = TREE_OPERAND (template, 0);
8902 template = TREE_OPERAND (template, 1);
8906 template = lookup_template_function (template, targs);
8909 return build3 (COMPONENT_REF, TREE_TYPE (template),
8910 object, template, NULL_TREE);
8912 return baselink_for_fns (template);
8917 tree r = RECUR (TREE_OPERAND (t, 0));
8919 if (REFERENCE_REF_P (t))
8921 /* A type conversion to reference type will be enclosed in
8922 such an indirect ref, but the substitution of the cast
8923 will have also added such an indirect ref. */
8924 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
8925 r = convert_from_reference (r);
8928 r = build_x_indirect_ref (r, "unary *");
8934 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8935 RECUR (TREE_OPERAND (t, 0)));
8938 case REINTERPRET_CAST_EXPR:
8939 case CONST_CAST_EXPR:
8940 case DYNAMIC_CAST_EXPR:
8941 case STATIC_CAST_EXPR:
8946 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8947 if (integral_constant_expression_p
8948 && !cast_valid_in_integral_constant_expression_p (type))
8950 error ("a cast to a type other than an integral or "
8951 "enumeration type cannot appear in a constant-expression");
8952 return error_mark_node;
8955 op = RECUR (TREE_OPERAND (t, 0));
8957 switch (TREE_CODE (t))
8960 return build_functional_cast (type, op);
8961 case REINTERPRET_CAST_EXPR:
8962 return build_reinterpret_cast (type, op);
8963 case CONST_CAST_EXPR:
8964 return build_const_cast (type, op);
8965 case DYNAMIC_CAST_EXPR:
8966 return build_dynamic_cast (type, op);
8967 case STATIC_CAST_EXPR:
8968 return build_static_cast (type, op);
8974 case POSTDECREMENT_EXPR:
8975 case POSTINCREMENT_EXPR:
8976 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8977 args, complain, in_decl);
8978 return build_x_unary_op (TREE_CODE (t), op1);
8980 case PREDECREMENT_EXPR:
8981 case PREINCREMENT_EXPR:
8985 case TRUTH_NOT_EXPR:
8986 case UNARY_PLUS_EXPR: /* Unary + */
8989 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
8992 op1 = TREE_OPERAND (t, 0);
8993 if (TREE_CODE (op1) == SCOPE_REF)
8994 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
8995 /*done=*/true, /*address_p=*/true);
8997 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
8999 if (TREE_CODE (op1) == LABEL_DECL)
9000 return finish_label_address_expr (DECL_NAME (op1));
9001 return build_x_unary_op (ADDR_EXPR, op1);
9006 case TRUNC_DIV_EXPR:
9008 case FLOOR_DIV_EXPR:
9009 case ROUND_DIV_EXPR:
9010 case EXACT_DIV_EXPR:
9014 case TRUNC_MOD_EXPR:
9015 case FLOOR_MOD_EXPR:
9016 case TRUTH_ANDIF_EXPR:
9017 case TRUTH_ORIF_EXPR:
9018 case TRUTH_AND_EXPR:
9034 return build_x_binary_op
9036 RECUR (TREE_OPERAND (t, 0)),
9037 RECUR (TREE_OPERAND (t, 1)),
9038 /*overloaded_p=*/NULL);
9041 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
9042 /*address_p=*/false);
9044 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9045 args, complain, in_decl);
9046 return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)),
9047 /*overloaded_p=*/NULL);
9051 op1 = TREE_OPERAND (t, 0);
9054 /* When there are no ARGS, we are trying to evaluate a
9055 non-dependent expression from the parser. Trying to do
9056 the substitutions may not work. */
9058 op1 = TREE_TYPE (op1);
9063 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
9064 /*function_p=*/false,
9065 /*integral_constant_expression_p=*/false);
9069 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
9071 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
9075 tree r = build_x_modify_expr
9076 (RECUR (TREE_OPERAND (t, 0)),
9077 TREE_CODE (TREE_OPERAND (t, 1)),
9078 RECUR (TREE_OPERAND (t, 2)));
9079 /* TREE_NO_WARNING must be set if either the expression was
9080 parenthesized or it uses an operator such as >>= rather
9081 than plain assignment. In the former case, it was already
9082 set and must be copied. In the latter case,
9083 build_x_modify_expr sets it and it must not be reset
9085 if (TREE_NO_WARNING (t))
9086 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9091 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9092 args, complain, in_decl);
9093 /* Remember that there was a reference to this entity. */
9096 return build_x_arrow (op1);
9100 (RECUR (TREE_OPERAND (t, 0)),
9101 RECUR (TREE_OPERAND (t, 1)),
9102 RECUR (TREE_OPERAND (t, 2)),
9103 RECUR (TREE_OPERAND (t, 3)),
9104 NEW_EXPR_USE_GLOBAL (t));
9107 return delete_sanity
9108 (RECUR (TREE_OPERAND (t, 0)),
9109 RECUR (TREE_OPERAND (t, 1)),
9110 DELETE_EXPR_USE_VEC (t),
9111 DELETE_EXPR_USE_GLOBAL (t));
9114 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
9115 RECUR (TREE_OPERAND (t, 1)));
9124 function = TREE_OPERAND (t, 0);
9125 /* When we parsed the expression, we determined whether or
9126 not Koenig lookup should be performed. */
9127 koenig_p = KOENIG_LOOKUP_P (t);
9128 if (TREE_CODE (function) == SCOPE_REF)
9131 function = tsubst_qualified_id (function, args, complain, in_decl,
9133 /*address_p=*/false);
9137 if (TREE_CODE (function) == COMPONENT_REF)
9139 tree op = TREE_OPERAND (function, 1);
9141 qualified_p = (TREE_CODE (op) == SCOPE_REF
9143 && BASELINK_QUALIFIED_P (op)));
9146 qualified_p = false;
9148 function = tsubst_copy_and_build (function, args, complain,
9151 integral_constant_expression_p);
9153 if (BASELINK_P (function))
9157 call_args = RECUR (TREE_OPERAND (t, 1));
9159 /* We do not perform argument-dependent lookup if normal
9160 lookup finds a non-function, in accordance with the
9161 expected resolution of DR 218. */
9163 && ((is_overloaded_fn (function)
9164 /* If lookup found a member function, the Koenig lookup is
9165 not appropriate, even if an unqualified-name was used
9166 to denote the function. */
9167 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
9168 || TREE_CODE (function) == IDENTIFIER_NODE))
9169 function = perform_koenig_lookup (function, call_args);
9171 if (TREE_CODE (function) == IDENTIFIER_NODE)
9173 unqualified_name_lookup_error (function);
9174 return error_mark_node;
9177 /* Remember that there was a reference to this entity. */
9178 if (DECL_P (function))
9179 mark_used (function);
9181 if (TREE_CODE (function) == OFFSET_REF)
9182 return build_offset_ref_call_from_tree (function, call_args);
9183 if (TREE_CODE (function) == COMPONENT_REF)
9185 if (!BASELINK_P (TREE_OPERAND (function, 1)))
9186 return finish_call_expr (function, call_args,
9187 /*disallow_virtual=*/false,
9188 /*koenig_p=*/false);
9190 return (build_new_method_call
9191 (TREE_OPERAND (function, 0),
9192 TREE_OPERAND (function, 1),
9193 call_args, NULL_TREE,
9194 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
9197 return finish_call_expr (function, call_args,
9198 /*disallow_virtual=*/qualified_p,
9203 return build_x_conditional_expr
9204 (RECUR (TREE_OPERAND (t, 0)),
9205 RECUR (TREE_OPERAND (t, 1)),
9206 RECUR (TREE_OPERAND (t, 2)));
9208 case PSEUDO_DTOR_EXPR:
9209 return finish_pseudo_destructor_expr
9210 (RECUR (TREE_OPERAND (t, 0)),
9211 RECUR (TREE_OPERAND (t, 1)),
9212 RECUR (TREE_OPERAND (t, 2)));
9216 tree purpose, value, chain;
9218 if (t == void_list_node)
9221 purpose = TREE_PURPOSE (t);
9223 purpose = RECUR (purpose);
9224 value = TREE_VALUE (t);
9226 value = RECUR (value);
9227 chain = TREE_CHAIN (t);
9228 if (chain && chain != void_type_node)
9229 chain = RECUR (chain);
9230 if (purpose == TREE_PURPOSE (t)
9231 && value == TREE_VALUE (t)
9232 && chain == TREE_CHAIN (t))
9234 return tree_cons (purpose, value, chain);
9243 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9244 args, complain, in_decl);
9245 /* Remember that there was a reference to this entity. */
9246 if (DECL_P (object))
9248 object_type = TREE_TYPE (object);
9250 member = TREE_OPERAND (t, 1);
9251 if (BASELINK_P (member))
9252 member = tsubst_baselink (member,
9253 non_reference (TREE_TYPE (object)),
9254 args, complain, in_decl);
9256 member = tsubst_copy (member, args, complain, in_decl);
9257 if (member == error_mark_node)
9258 return error_mark_node;
9260 if (object_type && !CLASS_TYPE_P (object_type))
9262 if (TREE_CODE (member) == BIT_NOT_EXPR)
9263 return finish_pseudo_destructor_expr (object,
9266 else if (TREE_CODE (member) == SCOPE_REF
9267 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
9268 return finish_pseudo_destructor_expr (object,
9272 else if (TREE_CODE (member) == SCOPE_REF
9273 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
9278 /* Lookup the template functions now that we know what the
9280 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
9281 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
9282 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
9283 /*is_type_p=*/false,
9284 /*complain=*/false);
9285 if (BASELINK_P (member))
9287 BASELINK_FUNCTIONS (member)
9288 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
9290 member = (adjust_result_of_qualified_name_lookup
9291 (member, BINFO_TYPE (BASELINK_BINFO (member)),
9296 qualified_name_lookup_error (object_type, tmpl, member);
9297 return error_mark_node;
9300 else if (TREE_CODE (member) == SCOPE_REF
9301 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
9302 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
9304 if (complain & tf_error)
9306 if (TYPE_P (TREE_OPERAND (member, 0)))
9307 error ("%qT is not a class or namespace",
9308 TREE_OPERAND (member, 0));
9310 error ("%qD is not a class or namespace",
9311 TREE_OPERAND (member, 0));
9313 return error_mark_node;
9315 else if (TREE_CODE (member) == FIELD_DECL)
9316 return finish_non_static_data_member (member, object, NULL_TREE);
9318 return finish_class_member_access_expr (object, member,
9319 /*template_p=*/false);
9324 (RECUR (TREE_OPERAND (t, 0)));
9328 VEC(constructor_elt,gc) *n;
9329 constructor_elt *ce;
9330 unsigned HOST_WIDE_INT idx;
9331 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9332 bool process_index_p;
9334 if (type == error_mark_node)
9335 return error_mark_node;
9337 /* digest_init will do the wrong thing if we let it. */
9338 if (type && TYPE_PTRMEMFUNC_P (type))
9341 /* We do not want to process the index of aggregate
9342 initializers as they are identifier nodes which will be
9343 looked up by digest_init. */
9344 process_index_p = !(type && IS_AGGR_TYPE (type));
9346 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
9347 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
9349 if (ce->index && process_index_p)
9350 ce->index = RECUR (ce->index);
9351 ce->value = RECUR (ce->value);
9354 if (TREE_HAS_CONSTRUCTOR (t))
9355 return finish_compound_literal (type, n);
9357 return build_constructor (NULL_TREE, n);
9362 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
9363 if (TYPE_P (operand_0))
9364 return get_typeid (operand_0);
9365 return build_typeid (operand_0);
9375 tree r = tsubst_copy (t, args, complain, in_decl);
9377 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
9378 /* If the original type was a reference, we'll be wrapped in
9379 the appropriate INDIRECT_REF. */
9380 r = convert_from_reference (r);
9385 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
9386 tsubst_copy (TREE_TYPE (t), args, complain,
9390 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
9394 tree old_stmt_expr = cur_stmt_expr;
9395 tree stmt_expr = begin_stmt_expr ();
9397 cur_stmt_expr = stmt_expr;
9398 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
9399 integral_constant_expression_p);
9400 stmt_expr = finish_stmt_expr (stmt_expr, false);
9401 cur_stmt_expr = old_stmt_expr;
9407 t = tsubst_copy (t, args, complain, in_decl);
9408 /* As in finish_id_expression, we resolve enumeration constants
9409 to their underlying values. */
9410 if (TREE_CODE (t) == CONST_DECL)
9412 used_types_insert (TREE_TYPE (t));
9413 return DECL_INITIAL (t);
9418 /* Handle Objective-C++ constructs, if appropriate. */
9421 = objcp_tsubst_copy_and_build (t, args, complain,
9422 in_decl, /*function_p=*/false);
9426 return tsubst_copy (t, args, complain, in_decl);
9432 /* Verify that the instantiated ARGS are valid. For type arguments,
9433 make sure that the type's linkage is ok. For non-type arguments,
9434 make sure they are constants if they are integral or enumerations.
9435 Emit an error under control of COMPLAIN, and return TRUE on error. */
9438 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
9440 int ix, len = DECL_NTPARMS (tmpl);
9441 bool result = false;
9443 for (ix = 0; ix != len; ix++)
9445 tree t = TREE_VEC_ELT (args, ix);
9449 /* [basic.link]: A name with no linkage (notably, the name
9450 of a class or enumeration declared in a local scope)
9451 shall not be used to declare an entity with linkage.
9452 This implies that names with no linkage cannot be used as
9453 template arguments. */
9454 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
9458 /* DR 488 makes use of a type with no linkage cause
9459 type deduction to fail. */
9460 if (complain & tf_error)
9462 if (TYPE_ANONYMOUS_P (nt))
9463 error ("%qT is/uses anonymous type", t);
9465 error ("template argument for %qD uses local type %qT",
9470 /* In order to avoid all sorts of complications, we do not
9471 allow variably-modified types as template arguments. */
9472 else if (variably_modified_type_p (t, NULL_TREE))
9474 if (complain & tf_error)
9475 error ("%qT is a variably modified type", t);
9479 /* A non-type argument of integral or enumerated type must be a
9481 else if (TREE_TYPE (t)
9482 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
9483 && !TREE_CONSTANT (t))
9485 if (complain & tf_error)
9486 error ("integral expression %qE is not constant", t);
9490 if (result && (complain & tf_error))
9491 error (" trying to instantiate %qD", tmpl);
9495 /* Instantiate the indicated variable or function template TMPL with
9496 the template arguments in TARG_PTR. */
9499 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
9504 HOST_WIDE_INT saved_processing_template_decl;
9506 if (tmpl == error_mark_node)
9507 return error_mark_node;
9509 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
9511 /* If this function is a clone, handle it specially. */
9512 if (DECL_CLONED_FUNCTION_P (tmpl))
9517 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
9519 if (spec == error_mark_node)
9520 return error_mark_node;
9522 /* Look for the clone. */
9523 FOR_EACH_CLONE (clone, spec)
9524 if (DECL_NAME (clone) == DECL_NAME (tmpl))
9526 /* We should always have found the clone by now. */
9531 /* Check to see if we already have this specialization. */
9532 spec = retrieve_specialization (tmpl, targ_ptr,
9533 /*class_specializations_p=*/false);
9534 if (spec != NULL_TREE)
9537 gen_tmpl = most_general_template (tmpl);
9538 if (tmpl != gen_tmpl)
9540 /* The TMPL is a partial instantiation. To get a full set of
9541 arguments we must add the arguments used to perform the
9542 partial instantiation. */
9543 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
9546 /* Check to see if we already have this specialization. */
9547 spec = retrieve_specialization (gen_tmpl, targ_ptr,
9548 /*class_specializations_p=*/false);
9549 if (spec != NULL_TREE)
9553 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
9555 return error_mark_node;
9557 /* We are building a FUNCTION_DECL, during which the access of its
9558 parameters and return types have to be checked. However this
9559 FUNCTION_DECL which is the desired context for access checking
9560 is not built yet. We solve this chicken-and-egg problem by
9561 deferring all checks until we have the FUNCTION_DECL. */
9562 push_deferring_access_checks (dk_deferred);
9564 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
9565 (because, for example, we have encountered a non-dependent
9566 function call in the body of a template function and must now
9567 determine which of several overloaded functions will be called),
9568 within the instantiation itself we are not processing a
9570 saved_processing_template_decl = processing_template_decl;
9571 processing_template_decl = 0;
9572 /* Substitute template parameters to obtain the specialization. */
9573 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
9574 targ_ptr, complain, gen_tmpl);
9575 processing_template_decl = saved_processing_template_decl;
9576 if (fndecl == error_mark_node)
9577 return error_mark_node;
9579 /* Now we know the specialization, compute access previously
9581 push_access_scope (fndecl);
9582 perform_deferred_access_checks ();
9583 pop_access_scope (fndecl);
9584 pop_deferring_access_checks ();
9586 /* The DECL_TI_TEMPLATE should always be the immediate parent
9587 template, not the most general template. */
9588 DECL_TI_TEMPLATE (fndecl) = tmpl;
9590 /* If we've just instantiated the main entry point for a function,
9591 instantiate all the alternate entry points as well. We do this
9592 by cloning the instantiation of the main entry point, not by
9593 instantiating the template clones. */
9594 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
9595 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
9600 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
9601 arguments that are being used when calling it. TARGS is a vector
9602 into which the deduced template arguments are placed.
9604 Return zero for success, 2 for an incomplete match that doesn't resolve
9605 all the types, and 1 for complete failure. An error message will be
9606 printed only for an incomplete match.
9608 If FN is a conversion operator, or we are trying to produce a specific
9609 specialization, RETURN_TYPE is the return type desired.
9611 The EXPLICIT_TARGS are explicit template arguments provided via a
9614 The parameter STRICT is one of:
9617 We are deducing arguments for a function call, as in
9621 We are deducing arguments for a conversion function, as in
9625 We are deducing arguments when doing an explicit instantiation
9626 as in [temp.explicit], when determining an explicit specialization
9627 as in [temp.expl.spec], or when taking the address of a function
9628 template, as in [temp.deduct.funcaddr]. */
9631 fn_type_unification (tree fn,
9632 tree explicit_targs,
9636 unification_kind_t strict,
9643 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
9645 fntype = TREE_TYPE (fn);
9650 The specified template arguments must match the template
9651 parameters in kind (i.e., type, nontype, template), and there
9652 must not be more arguments than there are parameters;
9653 otherwise type deduction fails.
9655 Nontype arguments must match the types of the corresponding
9656 nontype template parameters, or must be convertible to the
9657 types of the corresponding nontype parameters as specified in
9658 _temp.arg.nontype_, otherwise type deduction fails.
9660 All references in the function type of the function template
9661 to the corresponding template parameters are replaced by the
9662 specified template argument values. If a substitution in a
9663 template parameter or in the function type of the function
9664 template results in an invalid type, type deduction fails. */
9666 tree converted_args;
9669 if (explicit_targs == error_mark_node)
9673 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9674 explicit_targs, NULL_TREE, tf_none,
9675 /*require_all_args=*/false,
9676 /*use_default_args=*/false));
9677 if (converted_args == error_mark_node)
9680 /* Substitute the explicit args into the function type. This is
9681 necessary so that, for instance, explicitly declared function
9682 arguments can match null pointed constants. If we were given
9683 an incomplete set of explicit args, we must not do semantic
9684 processing during substitution as we could create partial
9686 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
9687 processing_template_decl += incomplete;
9688 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
9689 processing_template_decl -= incomplete;
9691 if (fntype == error_mark_node)
9694 /* Place the explicitly specified arguments in TARGS. */
9695 for (i = NUM_TMPL_ARGS (converted_args); i--;)
9696 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
9699 parms = TYPE_ARG_TYPES (fntype);
9700 /* Never do unification on the 'this' parameter. */
9701 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
9702 parms = TREE_CHAIN (parms);
9706 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
9707 args = tree_cons (NULL_TREE, return_type, args);
9710 /* We allow incomplete unification without an error message here
9711 because the standard doesn't seem to explicitly prohibit it. Our
9712 callers must be ready to deal with unification failures in any
9714 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9715 targs, parms, args, /*subr=*/0,
9719 /* All is well so far. Now, check:
9723 When all template arguments have been deduced, all uses of
9724 template parameters in nondeduced contexts are replaced with
9725 the corresponding deduced argument values. If the
9726 substitution results in an invalid type, as described above,
9727 type deduction fails. */
9728 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
9735 /* Adjust types before performing type deduction, as described in
9736 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
9737 sections are symmetric. PARM is the type of a function parameter
9738 or the return type of the conversion function. ARG is the type of
9739 the argument passed to the call, or the type of the value
9740 initialized with the result of the conversion function. */
9743 maybe_adjust_types_for_deduction (unification_kind_t strict,
9756 /* Swap PARM and ARG throughout the remainder of this
9757 function; the handling is precisely symmetric since PARM
9758 will initialize ARG rather than vice versa. */
9766 /* There is nothing to do in this case. */
9773 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9775 /* [temp.deduct.call]
9777 If P is not a reference type:
9779 --If A is an array type, the pointer type produced by the
9780 array-to-pointer standard conversion (_conv.array_) is
9781 used in place of A for type deduction; otherwise,
9783 --If A is a function type, the pointer type produced by
9784 the function-to-pointer standard conversion
9785 (_conv.func_) is used in place of A for type deduction;
9788 --If A is a cv-qualified type, the top level
9789 cv-qualifiers of A's type are ignored for type
9791 if (TREE_CODE (*arg) == ARRAY_TYPE)
9792 *arg = build_pointer_type (TREE_TYPE (*arg));
9793 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9794 *arg = build_pointer_type (*arg);
9796 *arg = TYPE_MAIN_VARIANT (*arg);
9799 /* [temp.deduct.call]
9801 If P is a cv-qualified type, the top level cv-qualifiers
9802 of P's type are ignored for type deduction. If P is a
9803 reference type, the type referred to by P is used for
9805 *parm = TYPE_MAIN_VARIANT (*parm);
9806 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9808 *parm = TREE_TYPE (*parm);
9809 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9812 /* DR 322. For conversion deduction, remove a reference type on parm
9813 too (which has been swapped into ARG). */
9814 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9815 *arg = TREE_TYPE (*arg);
9820 /* Most parms like fn_type_unification.
9822 If SUBR is 1, we're being called recursively (to unify the
9823 arguments of a function or method parameter of a function
9827 type_unification_real (tree tparms,
9832 unification_kind_t strict,
9837 int ntparms = TREE_VEC_LENGTH (tparms);
9839 int saw_undeduced = 0;
9842 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
9843 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
9844 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
9845 gcc_assert (ntparms > 0);
9850 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9851 | UNIFY_ALLOW_DERIVED);
9855 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9859 sub_strict = UNIFY_ALLOW_NONE;
9870 while (parms && parms != void_list_node
9871 && args && args != void_list_node)
9873 parm = TREE_VALUE (parms);
9874 parms = TREE_CHAIN (parms);
9875 arg = TREE_VALUE (args);
9876 args = TREE_CHAIN (args);
9878 if (arg == error_mark_node)
9880 if (arg == unknown_type_node)
9881 /* We can't deduce anything from this, but we might get all the
9882 template args from other function args. */
9885 /* Conversions will be performed on a function argument that
9886 corresponds with a function parameter that contains only
9887 non-deducible template parameters and explicitly specified
9888 template parameters. */
9889 if (!uses_template_parms (parm))
9894 type = TREE_TYPE (arg);
9898 if (same_type_p (parm, type))
9900 if (strict != DEDUCE_EXACT
9901 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
9910 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
9911 if (type_unknown_p (arg))
9913 /* [temp.deduct.type] A template-argument can be deduced from
9914 a pointer to function or pointer to member function
9915 argument if the set of overloaded functions does not
9916 contain function templates and at most one of a set of
9917 overloaded functions provides a unique match. */
9919 if (resolve_overloaded_unification
9920 (tparms, targs, parm, arg, strict, sub_strict)
9925 arg = TREE_TYPE (arg);
9926 if (arg == error_mark_node)
9931 int arg_strict = sub_strict;
9934 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9936 if (unify (tparms, targs, parm, arg, arg_strict))
9941 /* Fail if we've reached the end of the parm list, and more args
9942 are present, and the parm list isn't variadic. */
9943 if (args && args != void_list_node && parms == void_list_node)
9945 /* Fail if parms are left and they don't have default values. */
9946 if (parms && parms != void_list_node
9947 && TREE_PURPOSE (parms) == NULL_TREE)
9951 for (i = 0; i < ntparms; i++)
9952 if (!TREE_VEC_ELT (targs, i))
9956 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
9959 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
9961 /* If this is an undeduced nontype parameter that depends on
9962 a type parameter, try another pass; its type may have been
9963 deduced from a later argument than the one from which
9964 this parameter can be deduced. */
9965 if (TREE_CODE (tparm) == PARM_DECL
9966 && uses_template_parms (TREE_TYPE (tparm))
9967 && !saw_undeduced++)
9976 /* Subroutine of type_unification_real. Args are like the variables at the
9977 call site. ARG is an overloaded function (or template-id); we try
9978 deducing template args from each of the overloads, and if only one
9979 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
9982 resolve_overloaded_unification (tree tparms,
9986 unification_kind_t strict,
9989 tree tempargs = copy_node (targs);
9993 if (TREE_CODE (arg) == ADDR_EXPR)
9995 arg = TREE_OPERAND (arg, 0);
10001 if (TREE_CODE (arg) == COMPONENT_REF)
10002 /* Handle `&x' where `x' is some static or non-static member
10004 arg = TREE_OPERAND (arg, 1);
10006 if (TREE_CODE (arg) == OFFSET_REF)
10007 arg = TREE_OPERAND (arg, 1);
10009 /* Strip baselink information. */
10010 if (BASELINK_P (arg))
10011 arg = BASELINK_FUNCTIONS (arg);
10013 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
10015 /* If we got some explicit template args, we need to plug them into
10016 the affected templates before we try to unify, in case the
10017 explicit args will completely resolve the templates in question. */
10019 tree expl_subargs = TREE_OPERAND (arg, 1);
10020 arg = TREE_OPERAND (arg, 0);
10022 for (; arg; arg = OVL_NEXT (arg))
10024 tree fn = OVL_CURRENT (arg);
10025 tree subargs, elem;
10027 if (TREE_CODE (fn) != TEMPLATE_DECL)
10030 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
10031 expl_subargs, /*check_ret=*/false);
10034 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
10035 good += try_one_overload (tparms, targs, tempargs, parm,
10036 elem, strict, sub_strict, addr_p);
10042 gcc_assert (TREE_CODE (arg) == OVERLOAD
10043 || TREE_CODE (arg) == FUNCTION_DECL);
10045 for (; arg; arg = OVL_NEXT (arg))
10046 good += try_one_overload (tparms, targs, tempargs, parm,
10047 TREE_TYPE (OVL_CURRENT (arg)),
10048 strict, sub_strict, addr_p);
10051 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10052 to function or pointer to member function argument if the set of
10053 overloaded functions does not contain function templates and at most
10054 one of a set of overloaded functions provides a unique match.
10056 So if we found multiple possibilities, we return success but don't
10057 deduce anything. */
10061 int i = TREE_VEC_LENGTH (targs);
10063 if (TREE_VEC_ELT (tempargs, i))
10064 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
10072 /* Subroutine of resolve_overloaded_unification; does deduction for a single
10073 overload. Fills TARGS with any deduced arguments, or error_mark_node if
10074 different overloads deduce different arguments for a given parm.
10075 ADDR_P is true if the expression for which deduction is being
10076 performed was of the form "& fn" rather than simply "fn".
10078 Returns 1 on success. */
10081 try_one_overload (tree tparms,
10086 unification_kind_t strict,
10094 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10095 to function or pointer to member function argument if the set of
10096 overloaded functions does not contain function templates and at most
10097 one of a set of overloaded functions provides a unique match.
10099 So if this is a template, just return success. */
10101 if (uses_template_parms (arg))
10104 if (TREE_CODE (arg) == METHOD_TYPE)
10105 arg = build_ptrmemfunc_type (build_pointer_type (arg));
10107 arg = build_pointer_type (arg);
10109 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
10111 /* We don't copy orig_targs for this because if we have already deduced
10112 some template args from previous args, unify would complain when we
10113 try to deduce a template parameter for the same argument, even though
10114 there isn't really a conflict. */
10115 nargs = TREE_VEC_LENGTH (targs);
10116 tempargs = make_tree_vec (nargs);
10118 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
10121 /* First make sure we didn't deduce anything that conflicts with
10122 explicitly specified args. */
10123 for (i = nargs; i--; )
10125 tree elt = TREE_VEC_ELT (tempargs, i);
10126 tree oldelt = TREE_VEC_ELT (orig_targs, i);
10130 else if (uses_template_parms (elt))
10131 /* Since we're unifying against ourselves, we will fill in
10132 template args used in the function parm list with our own
10133 template parms. Discard them. */
10134 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
10135 else if (oldelt && !template_args_equal (oldelt, elt))
10139 for (i = nargs; i--; )
10141 tree elt = TREE_VEC_ELT (tempargs, i);
10144 TREE_VEC_ELT (targs, i) = elt;
10150 /* PARM is a template class (perhaps with unbound template
10151 parameters). ARG is a fully instantiated type. If ARG can be
10152 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
10153 TARGS are as for unify. */
10156 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
10158 tree copy_of_targs;
10160 if (!CLASSTYPE_TEMPLATE_INFO (arg)
10161 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
10162 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
10165 /* We need to make a new template argument vector for the call to
10166 unify. If we used TARGS, we'd clutter it up with the result of
10167 the attempted unification, even if this class didn't work out.
10168 We also don't want to commit ourselves to all the unifications
10169 we've already done, since unification is supposed to be done on
10170 an argument-by-argument basis. In other words, consider the
10171 following pathological case:
10173 template <int I, int J, int K>
10176 template <int I, int J>
10177 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
10179 template <int I, int J, int K>
10180 void f(S<I, J, K>, S<I, I, I>);
10189 Now, by the time we consider the unification involving `s2', we
10190 already know that we must have `f<0, 0, 0>'. But, even though
10191 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
10192 because there are two ways to unify base classes of S<0, 1, 2>
10193 with S<I, I, I>. If we kept the already deduced knowledge, we
10194 would reject the possibility I=1. */
10195 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
10197 /* If unification failed, we're done. */
10198 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
10199 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
10205 /* Given a template type PARM and a class type ARG, find the unique
10206 base type in ARG that is an instance of PARM. We do not examine
10207 ARG itself; only its base-classes. If there is not exactly one
10208 appropriate base class, return NULL_TREE. PARM may be the type of
10209 a partial specialization, as well as a plain template type. Used
10213 get_template_base (tree tparms, tree targs, tree parm, tree arg)
10215 tree rval = NULL_TREE;
10218 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
10220 binfo = TYPE_BINFO (complete_type (arg));
10222 /* The type could not be completed. */
10225 /* Walk in inheritance graph order. The search order is not
10226 important, and this avoids multiple walks of virtual bases. */
10227 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
10229 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
10233 /* If there is more than one satisfactory baseclass, then:
10237 If they yield more than one possible deduced A, the type
10241 if (rval && !same_type_p (r, rval))
10251 /* Returns the level of DECL, which declares a template parameter. */
10254 template_decl_level (tree decl)
10256 switch (TREE_CODE (decl))
10259 case TEMPLATE_DECL:
10260 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
10263 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
10266 gcc_unreachable ();
10271 /* Decide whether ARG can be unified with PARM, considering only the
10272 cv-qualifiers of each type, given STRICT as documented for unify.
10273 Returns nonzero iff the unification is OK on that basis. */
10276 check_cv_quals_for_unify (int strict, tree arg, tree parm)
10278 int arg_quals = cp_type_quals (arg);
10279 int parm_quals = cp_type_quals (parm);
10281 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10282 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10284 /* Although a CVR qualifier is ignored when being applied to a
10285 substituted template parameter ([8.3.2]/1 for example), that
10286 does not apply during deduction [14.8.2.4]/1, (even though
10287 that is not explicitly mentioned, [14.8.2.4]/9 indicates
10288 this). Except when we're allowing additional CV qualifiers
10289 at the outer level [14.8.2.1]/3,1st bullet. */
10290 if ((TREE_CODE (arg) == REFERENCE_TYPE
10291 || TREE_CODE (arg) == FUNCTION_TYPE
10292 || TREE_CODE (arg) == METHOD_TYPE)
10293 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
10296 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
10297 && (parm_quals & TYPE_QUAL_RESTRICT))
10301 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10302 && (arg_quals & parm_quals) != parm_quals)
10305 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
10306 && (parm_quals & arg_quals) != arg_quals)
10312 /* Deduce the value of template parameters. TPARMS is the (innermost)
10313 set of template parameters to a template. TARGS is the bindings
10314 for those template parameters, as determined thus far; TARGS may
10315 include template arguments for outer levels of template parameters
10316 as well. PARM is a parameter to a template function, or a
10317 subcomponent of that parameter; ARG is the corresponding argument.
10318 This function attempts to match PARM with ARG in a manner
10319 consistent with the existing assignments in TARGS. If more values
10320 are deduced, then TARGS is updated.
10322 Returns 0 if the type deduction succeeds, 1 otherwise. The
10323 parameter STRICT is a bitwise or of the following flags:
10326 Require an exact match between PARM and ARG.
10327 UNIFY_ALLOW_MORE_CV_QUAL:
10328 Allow the deduced ARG to be more cv-qualified (by qualification
10329 conversion) than ARG.
10330 UNIFY_ALLOW_LESS_CV_QUAL:
10331 Allow the deduced ARG to be less cv-qualified than ARG.
10332 UNIFY_ALLOW_DERIVED:
10333 Allow the deduced ARG to be a template base class of ARG,
10334 or a pointer to a template base class of the type pointed to by
10336 UNIFY_ALLOW_INTEGER:
10337 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
10338 case for more information.
10339 UNIFY_ALLOW_OUTER_LEVEL:
10340 This is the outermost level of a deduction. Used to determine validity
10341 of qualification conversions. A valid qualification conversion must
10342 have const qualified pointers leading up to the inner type which
10343 requires additional CV quals, except at the outer level, where const
10344 is not required [conv.qual]. It would be normal to set this flag in
10345 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
10346 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
10347 This is the outermost level of a deduction, and PARM can be more CV
10348 qualified at this point.
10349 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
10350 This is the outermost level of a deduction, and PARM can be less CV
10351 qualified at this point. */
10354 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
10359 int strict_in = strict;
10361 /* I don't think this will do the right thing with respect to types.
10362 But the only case I've seen it in so far has been array bounds, where
10363 signedness is the only information lost, and I think that will be
10365 while (TREE_CODE (parm) == NOP_EXPR)
10366 parm = TREE_OPERAND (parm, 0);
10368 if (arg == error_mark_node)
10370 if (arg == unknown_type_node)
10371 /* We can't deduce anything from this, but we might get all the
10372 template args from other function args. */
10375 /* If PARM uses template parameters, then we can't bail out here,
10376 even if ARG == PARM, since we won't record unifications for the
10377 template parameters. We might need them if we're trying to
10378 figure out which of two things is more specialized. */
10379 if (arg == parm && !uses_template_parms (parm))
10382 /* Immediately reject some pairs that won't unify because of
10383 cv-qualification mismatches. */
10384 if (TREE_CODE (arg) == TREE_CODE (parm)
10386 /* It is the elements of the array which hold the cv quals of an array
10387 type, and the elements might be template type parms. We'll check
10388 when we recurse. */
10389 && TREE_CODE (arg) != ARRAY_TYPE
10390 /* We check the cv-qualifiers when unifying with template type
10391 parameters below. We want to allow ARG `const T' to unify with
10392 PARM `T' for example, when computing which of two templates
10393 is more specialized, for example. */
10394 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
10395 && !check_cv_quals_for_unify (strict_in, arg, parm))
10398 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
10399 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
10400 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
10401 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
10402 strict &= ~UNIFY_ALLOW_DERIVED;
10403 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
10404 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
10406 switch (TREE_CODE (parm))
10408 case TYPENAME_TYPE:
10410 case UNBOUND_CLASS_TEMPLATE:
10411 /* In a type which contains a nested-name-specifier, template
10412 argument values cannot be deduced for template parameters used
10413 within the nested-name-specifier. */
10416 case TEMPLATE_TYPE_PARM:
10417 case TEMPLATE_TEMPLATE_PARM:
10418 case BOUND_TEMPLATE_TEMPLATE_PARM:
10419 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10421 if (TEMPLATE_TYPE_LEVEL (parm)
10422 != template_decl_level (tparm))
10423 /* The PARM is not one we're trying to unify. Just check
10424 to see if it matches ARG. */
10425 return (TREE_CODE (arg) == TREE_CODE (parm)
10426 && same_type_p (parm, arg)) ? 0 : 1;
10427 idx = TEMPLATE_TYPE_IDX (parm);
10428 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10429 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
10431 /* Check for mixed types and values. */
10432 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10433 && TREE_CODE (tparm) != TYPE_DECL)
10434 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10435 && TREE_CODE (tparm) != TEMPLATE_DECL))
10438 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10440 /* ARG must be constructed from a template class or a template
10441 template parameter. */
10442 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
10443 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
10447 tree parmvec = TYPE_TI_ARGS (parm);
10448 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
10450 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
10453 /* The resolution to DR150 makes clear that default
10454 arguments for an N-argument may not be used to bind T
10455 to a template template parameter with fewer than N
10456 parameters. It is not safe to permit the binding of
10457 default arguments as an extension, as that may change
10458 the meaning of a conforming program. Consider:
10460 struct Dense { static const unsigned int dim = 1; };
10462 template <template <typename> class View,
10464 void operator+(float, View<Block> const&);
10466 template <typename Block,
10467 unsigned int Dim = Block::dim>
10468 struct Lvalue_proxy { operator float() const; };
10472 Lvalue_proxy<Dense> p;
10477 Here, if Lvalue_proxy is permitted to bind to View, then
10478 the global operator+ will be used; if they are not, the
10479 Lvalue_proxy will be converted to float. */
10480 if (coerce_template_parms (argtmplvec, parmvec,
10481 TYPE_TI_TEMPLATE (parm),
10483 /*require_all_args=*/true,
10484 /*use_default_args=*/false)
10485 == error_mark_node)
10488 /* Deduce arguments T, i from TT<T> or TT<i>.
10489 We check each element of PARMVEC and ARGVEC individually
10490 rather than the whole TREE_VEC since they can have
10491 different number of elements. */
10493 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
10495 if (unify (tparms, targs,
10496 TREE_VEC_ELT (parmvec, i),
10497 TREE_VEC_ELT (argvec, i),
10502 arg = TYPE_TI_TEMPLATE (arg);
10504 /* Fall through to deduce template name. */
10507 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10508 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10510 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
10512 /* Simple cases: Value already set, does match or doesn't. */
10513 if (targ != NULL_TREE && template_args_equal (targ, arg))
10520 /* If PARM is `const T' and ARG is only `int', we don't have
10521 a match unless we are allowing additional qualification.
10522 If ARG is `const int' and PARM is just `T' that's OK;
10523 that binds `const int' to `T'. */
10524 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
10528 /* Consider the case where ARG is `const volatile int' and
10529 PARM is `const T'. Then, T should be `volatile int'. */
10530 arg = cp_build_qualified_type_real
10531 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
10532 if (arg == error_mark_node)
10535 /* Simple cases: Value already set, does match or doesn't. */
10536 if (targ != NULL_TREE && same_type_p (targ, arg))
10541 /* Make sure that ARG is not a variable-sized array. (Note
10542 that were talking about variable-sized arrays (like
10543 `int[n]'), rather than arrays of unknown size (like
10544 `int[]').) We'll get very confused by such a type since
10545 the bound of the array will not be computable in an
10546 instantiation. Besides, such types are not allowed in
10547 ISO C++, so we can do as we please here. */
10548 if (variably_modified_type_p (arg, NULL_TREE))
10552 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10555 case TEMPLATE_PARM_INDEX:
10556 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10557 if (tparm == error_mark_node)
10560 if (TEMPLATE_PARM_LEVEL (parm)
10561 != template_decl_level (tparm))
10562 /* The PARM is not one we're trying to unify. Just check
10563 to see if it matches ARG. */
10564 return !(TREE_CODE (arg) == TREE_CODE (parm)
10565 && cp_tree_equal (parm, arg));
10567 idx = TEMPLATE_PARM_IDX (parm);
10568 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10571 return !cp_tree_equal (targ, arg);
10573 /* [temp.deduct.type] If, in the declaration of a function template
10574 with a non-type template-parameter, the non-type
10575 template-parameter is used in an expression in the function
10576 parameter-list and, if the corresponding template-argument is
10577 deduced, the template-argument type shall match the type of the
10578 template-parameter exactly, except that a template-argument
10579 deduced from an array bound may be of any integral type.
10580 The non-type parameter might use already deduced type parameters. */
10581 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
10582 if (!TREE_TYPE (arg))
10583 /* Template-parameter dependent expression. Just accept it for now.
10584 It will later be processed in convert_template_argument. */
10586 else if (same_type_p (TREE_TYPE (arg), tparm))
10588 else if ((strict & UNIFY_ALLOW_INTEGER)
10589 && (TREE_CODE (tparm) == INTEGER_TYPE
10590 || TREE_CODE (tparm) == BOOLEAN_TYPE))
10591 /* Convert the ARG to the type of PARM; the deduced non-type
10592 template argument must exactly match the types of the
10593 corresponding parameter. */
10594 arg = fold (build_nop (TREE_TYPE (parm), arg));
10595 else if (uses_template_parms (tparm))
10596 /* We haven't deduced the type of this parameter yet. Try again
10602 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10607 /* A pointer-to-member constant can be unified only with
10608 another constant. */
10609 if (TREE_CODE (arg) != PTRMEM_CST)
10612 /* Just unify the class member. It would be useless (and possibly
10613 wrong, depending on the strict flags) to unify also
10614 PTRMEM_CST_CLASS, because we want to be sure that both parm and
10615 arg refer to the same variable, even if through different
10616 classes. For instance:
10618 struct A { int x; };
10621 Unification of &A::x and &B::x must succeed. */
10622 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
10623 PTRMEM_CST_MEMBER (arg), strict);
10628 if (TREE_CODE (arg) != POINTER_TYPE)
10631 /* [temp.deduct.call]
10633 A can be another pointer or pointer to member type that can
10634 be converted to the deduced A via a qualification
10635 conversion (_conv.qual_).
10637 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
10638 This will allow for additional cv-qualification of the
10639 pointed-to types if appropriate. */
10641 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10642 /* The derived-to-base conversion only persists through one
10643 level of pointers. */
10644 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10646 return unify (tparms, targs, TREE_TYPE (parm),
10647 TREE_TYPE (arg), strict);
10650 case REFERENCE_TYPE:
10651 if (TREE_CODE (arg) != REFERENCE_TYPE)
10653 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10654 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10657 if (TREE_CODE (arg) != ARRAY_TYPE)
10659 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10660 != (TYPE_DOMAIN (arg) == NULL_TREE))
10662 if (TYPE_DOMAIN (parm) != NULL_TREE)
10669 /* Our representation of array types uses "N - 1" as the
10670 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
10671 not an integer constant. We cannot unify arbitrarily
10672 complex expressions, so we eliminate the MINUS_EXPRs
10674 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
10675 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
10678 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
10679 parm_max = TREE_OPERAND (parm_max, 0);
10681 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
10682 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
10685 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
10686 trying to unify the type of a variable with the type
10687 of a template parameter. For example:
10689 template <unsigned int N>
10690 void f (char (&) [N]);
10697 Here, the type of the ARG will be "int [g(i)]", and
10698 may be a SAVE_EXPR, etc. */
10699 if (TREE_CODE (arg_max) != MINUS_EXPR)
10701 arg_max = TREE_OPERAND (arg_max, 0);
10704 /* If only one of the bounds used a MINUS_EXPR, compensate
10705 by adding one to the other bound. */
10706 if (parm_cst && !arg_cst)
10707 parm_max = fold_build2 (PLUS_EXPR,
10711 else if (arg_cst && !parm_cst)
10712 arg_max = fold_build2 (PLUS_EXPR,
10717 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
10720 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10721 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10728 case ENUMERAL_TYPE:
10730 if (TREE_CODE (arg) != TREE_CODE (parm))
10733 /* We have already checked cv-qualification at the top of the
10735 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10738 /* As far as unification is concerned, this wins. Later checks
10739 will invalidate it if necessary. */
10742 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10743 /* Type INTEGER_CST can come from ordinary constant template args. */
10745 while (TREE_CODE (arg) == NOP_EXPR)
10746 arg = TREE_OPERAND (arg, 0);
10748 if (TREE_CODE (arg) != INTEGER_CST)
10750 return !tree_int_cst_equal (parm, arg);
10755 if (TREE_CODE (arg) != TREE_VEC)
10757 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10759 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10760 if (unify (tparms, targs,
10761 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10769 if (TREE_CODE (arg) != TREE_CODE (parm))
10772 if (TYPE_PTRMEMFUNC_P (parm))
10774 if (!TYPE_PTRMEMFUNC_P (arg))
10777 return unify (tparms, targs,
10778 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10779 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10783 if (CLASSTYPE_TEMPLATE_INFO (parm))
10785 tree t = NULL_TREE;
10787 if (strict_in & UNIFY_ALLOW_DERIVED)
10789 /* First, we try to unify the PARM and ARG directly. */
10790 t = try_class_unification (tparms, targs,
10795 /* Fallback to the special case allowed in
10796 [temp.deduct.call]:
10798 If P is a class, and P has the form
10799 template-id, then A can be a derived class of
10800 the deduced A. Likewise, if P is a pointer to
10801 a class of the form template-id, A can be a
10802 pointer to a derived class pointed to by the
10804 t = get_template_base (tparms, targs, parm, arg);
10810 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10811 && (CLASSTYPE_TI_TEMPLATE (parm)
10812 == CLASSTYPE_TI_TEMPLATE (arg)))
10813 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10814 Then, we should unify `int' and `U'. */
10817 /* There's no chance of unification succeeding. */
10820 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10821 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10823 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10828 case FUNCTION_TYPE:
10829 if (TREE_CODE (arg) != TREE_CODE (parm))
10832 /* CV qualifications for methods can never be deduced, they must
10833 match exactly. We need to check them explicitly here,
10834 because type_unification_real treats them as any other
10835 cvqualified parameter. */
10836 if (TREE_CODE (parm) == METHOD_TYPE
10837 && (!check_cv_quals_for_unify
10839 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
10840 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
10843 if (unify (tparms, targs, TREE_TYPE (parm),
10844 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10846 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10847 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
10851 /* Unify a pointer to member with a pointer to member function, which
10852 deduces the type of the member as a function type. */
10853 if (TYPE_PTRMEMFUNC_P (arg))
10857 cp_cv_quals cv_quals;
10859 /* Check top-level cv qualifiers */
10860 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
10863 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10864 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
10867 /* Determine the type of the function we are unifying against. */
10868 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
10870 build_function_type (TREE_TYPE (method_type),
10871 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
10873 /* Extract the cv-qualifiers of the member function from the
10874 implicit object parameter and place them on the function
10875 type to be restored later. */
10877 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
10878 fntype = build_qualified_type (fntype, cv_quals);
10879 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
10882 if (TREE_CODE (arg) != OFFSET_TYPE)
10884 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10885 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10887 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10891 if (DECL_TEMPLATE_PARM_P (parm))
10892 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10893 if (arg != integral_constant_value (parm))
10898 case TEMPLATE_DECL:
10899 /* Matched cases are handled by the ARG == PARM test above. */
10903 gcc_assert (EXPR_P (parm));
10905 /* We must be looking at an expression. This can happen with
10909 void foo(S<I>, S<I + 2>);
10911 This is a "nondeduced context":
10915 The nondeduced contexts are:
10917 --A type that is a template-id in which one or more of
10918 the template-arguments is an expression that references
10919 a template-parameter.
10921 In these cases, we assume deduction succeeded, but don't
10922 actually infer any unifications. */
10924 if (!uses_template_parms (parm)
10925 && !template_args_equal (parm, arg))
10932 /* Note that DECL can be defined in this translation unit, if
10936 mark_definable (tree decl)
10939 DECL_NOT_REALLY_EXTERN (decl) = 1;
10940 FOR_EACH_CLONE (clone, decl)
10941 DECL_NOT_REALLY_EXTERN (clone) = 1;
10944 /* Called if RESULT is explicitly instantiated, or is a member of an
10945 explicitly instantiated class. */
10948 mark_decl_instantiated (tree result, int extern_p)
10950 SET_DECL_EXPLICIT_INSTANTIATION (result);
10952 /* If this entity has already been written out, it's too late to
10953 make any modifications. */
10954 if (TREE_ASM_WRITTEN (result))
10957 if (TREE_CODE (result) != FUNCTION_DECL)
10958 /* The TREE_PUBLIC flag for function declarations will have been
10959 set correctly by tsubst. */
10960 TREE_PUBLIC (result) = 1;
10962 /* This might have been set by an earlier implicit instantiation. */
10963 DECL_COMDAT (result) = 0;
10966 DECL_NOT_REALLY_EXTERN (result) = 0;
10969 mark_definable (result);
10970 /* Always make artificials weak. */
10971 if (DECL_ARTIFICIAL (result) && flag_weak)
10972 comdat_linkage (result);
10973 /* For WIN32 we also want to put explicit instantiations in
10974 linkonce sections. */
10975 else if (TREE_PUBLIC (result))
10976 maybe_make_one_only (result);
10979 /* If EXTERN_P, then this function will not be emitted -- unless
10980 followed by an explicit instantiation, at which point its linkage
10981 will be adjusted. If !EXTERN_P, then this function will be
10982 emitted here. In neither circumstance do we want
10983 import_export_decl to adjust the linkage. */
10984 DECL_INTERFACE_KNOWN (result) = 1;
10987 /* Given two function templates PAT1 and PAT2, return:
10989 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
10990 -1 if PAT2 is more specialized than PAT1.
10991 0 if neither is more specialized.
10993 LEN indicates the number of parameters we should consider
10994 (defaulted parameters should not be considered).
10996 The 1998 std underspecified function template partial ordering, and
10997 DR214 addresses the issue. We take pairs of arguments, one from
10998 each of the templates, and deduce them against each other. One of
10999 the templates will be more specialized if all the *other*
11000 template's arguments deduce against its arguments and at least one
11001 of its arguments *does* *not* deduce against the other template's
11002 corresponding argument. Deduction is done as for class templates.
11003 The arguments used in deduction have reference and top level cv
11004 qualifiers removed. Iff both arguments were originally reference
11005 types *and* deduction succeeds in both directions, the template
11006 with the more cv-qualified argument wins for that pairing (if
11007 neither is more cv-qualified, they both are equal). Unlike regular
11008 deduction, after all the arguments have been deduced in this way,
11009 we do *not* verify the deduced template argument values can be
11010 substituted into non-deduced contexts, nor do we have to verify
11011 that all template arguments have been deduced. */
11014 more_specialized_fn (tree pat1, tree pat2, int len)
11016 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
11017 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
11018 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
11019 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
11020 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
11021 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
11022 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
11023 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
11027 /* Remove the this parameter from non-static member functions. If
11028 one is a non-static member function and the other is not a static
11029 member function, remove the first parameter from that function
11030 also. This situation occurs for operator functions where we
11031 locate both a member function (with this pointer) and non-member
11032 operator (with explicit first operand). */
11033 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
11035 len--; /* LEN is the number of significant arguments for DECL1 */
11036 args1 = TREE_CHAIN (args1);
11037 if (!DECL_STATIC_FUNCTION_P (decl2))
11038 args2 = TREE_CHAIN (args2);
11040 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
11042 args2 = TREE_CHAIN (args2);
11043 if (!DECL_STATIC_FUNCTION_P (decl1))
11046 args1 = TREE_CHAIN (args1);
11050 /* If only one is a conversion operator, they are unordered. */
11051 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
11054 /* Consider the return type for a conversion function */
11055 if (DECL_CONV_FN_P (decl1))
11057 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
11058 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
11062 processing_template_decl++;
11066 tree arg1 = TREE_VALUE (args1);
11067 tree arg2 = TREE_VALUE (args2);
11068 int deduce1, deduce2;
11072 if (TREE_CODE (arg1) == REFERENCE_TYPE)
11074 arg1 = TREE_TYPE (arg1);
11075 quals1 = cp_type_quals (arg1);
11078 if (TREE_CODE (arg2) == REFERENCE_TYPE)
11080 arg2 = TREE_TYPE (arg2);
11081 quals2 = cp_type_quals (arg2);
11084 if ((quals1 < 0) != (quals2 < 0))
11086 /* Only of the args is a reference, see if we should apply
11087 array/function pointer decay to it. This is not part of
11088 DR214, but is, IMHO, consistent with the deduction rules
11089 for the function call itself, and with our earlier
11090 implementation of the underspecified partial ordering
11091 rules. (nathan). */
11094 switch (TREE_CODE (arg1))
11097 arg1 = TREE_TYPE (arg1);
11099 case FUNCTION_TYPE:
11100 arg1 = build_pointer_type (arg1);
11109 switch (TREE_CODE (arg2))
11112 arg2 = TREE_TYPE (arg2);
11114 case FUNCTION_TYPE:
11115 arg2 = build_pointer_type (arg2);
11124 arg1 = TYPE_MAIN_VARIANT (arg1);
11125 arg2 = TYPE_MAIN_VARIANT (arg2);
11127 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
11128 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
11134 if (better1 < 0 && better2 < 0)
11135 /* We've failed to deduce something in either direction.
11136 These must be unordered. */
11139 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
11141 /* Deduces in both directions, see if quals can
11142 disambiguate. Pretend the worse one failed to deduce. */
11143 if ((quals1 & quals2) == quals2)
11145 if ((quals1 & quals2) == quals1)
11148 if (deduce1 && !deduce2 && !better2)
11150 if (deduce2 && !deduce1 && !better1)
11153 args1 = TREE_CHAIN (args1);
11154 args2 = TREE_CHAIN (args2);
11157 processing_template_decl--;
11159 return (better1 > 0) - (better2 > 0);
11162 /* Determine which of two partial specializations is more specialized.
11164 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
11165 to the first partial specialization. The TREE_VALUE is the
11166 innermost set of template parameters for the partial
11167 specialization. PAT2 is similar, but for the second template.
11169 Return 1 if the first partial specialization is more specialized;
11170 -1 if the second is more specialized; 0 if neither is more
11173 See [temp.class.order] for information about determining which of
11174 two templates is more specialized. */
11177 more_specialized_class (tree pat1, tree pat2)
11183 tmpl1 = TREE_TYPE (pat1);
11184 tmpl2 = TREE_TYPE (pat2);
11186 /* Just like what happens for functions, if we are ordering between
11187 different class template specializations, we may encounter dependent
11188 types in the arguments, and we need our dependency check functions
11189 to behave correctly. */
11190 ++processing_template_decl;
11191 targs = get_class_bindings (TREE_VALUE (pat1),
11192 CLASSTYPE_TI_ARGS (tmpl1),
11193 CLASSTYPE_TI_ARGS (tmpl2));
11197 targs = get_class_bindings (TREE_VALUE (pat2),
11198 CLASSTYPE_TI_ARGS (tmpl2),
11199 CLASSTYPE_TI_ARGS (tmpl1));
11202 --processing_template_decl;
11207 /* Return the template arguments that will produce the function signature
11208 DECL from the function template FN, with the explicit template
11209 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
11210 also match. Return NULL_TREE if no satisfactory arguments could be
11214 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
11216 int ntparms = DECL_NTPARMS (fn);
11217 tree targs = make_tree_vec (ntparms);
11219 tree decl_arg_types;
11221 /* Substitute the explicit template arguments into the type of DECL.
11222 The call to fn_type_unification will handle substitution into the
11224 decl_type = TREE_TYPE (decl);
11225 if (explicit_args && uses_template_parms (decl_type))
11228 tree converted_args;
11230 if (DECL_TEMPLATE_INFO (decl))
11231 tmpl = DECL_TI_TEMPLATE (decl);
11233 /* We can get here for some invalid specializations. */
11237 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
11238 explicit_args, NULL_TREE,
11240 /*require_all_args=*/false,
11241 /*use_default_args=*/false);
11242 if (converted_args == error_mark_node)
11245 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
11246 if (decl_type == error_mark_node)
11250 decl_arg_types = TYPE_ARG_TYPES (decl_type);
11251 /* Never do unification on the 'this' parameter. */
11252 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
11253 decl_arg_types = TREE_CHAIN (decl_arg_types);
11255 if (fn_type_unification (fn, explicit_args, targs,
11257 (check_rettype || DECL_CONV_FN_P (fn)
11258 ? TREE_TYPE (decl_type) : NULL_TREE),
11259 DEDUCE_EXACT, LOOKUP_NORMAL))
11265 /* Return the innermost template arguments that, when applied to a
11266 template specialization whose innermost template parameters are
11267 TPARMS, and whose specialization arguments are PARMS, yield the
11270 For example, suppose we have:
11272 template <class T, class U> struct S {};
11273 template <class T> struct S<T*, int> {};
11275 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
11276 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
11277 int}. The resulting vector will be {double}, indicating that `T'
11278 is bound to `double'. */
11281 get_class_bindings (tree tparms, tree spec_args, tree args)
11283 int i, ntparms = TREE_VEC_LENGTH (tparms);
11285 tree innermost_deduced_args;
11287 innermost_deduced_args = make_tree_vec (ntparms);
11288 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
11290 deduced_args = copy_node (args);
11291 SET_TMPL_ARGS_LEVEL (deduced_args,
11292 TMPL_ARGS_DEPTH (deduced_args),
11293 innermost_deduced_args);
11296 deduced_args = innermost_deduced_args;
11298 if (unify (tparms, deduced_args,
11299 INNERMOST_TEMPLATE_ARGS (spec_args),
11300 INNERMOST_TEMPLATE_ARGS (args),
11304 for (i = 0; i < ntparms; ++i)
11305 if (! TREE_VEC_ELT (innermost_deduced_args, i))
11308 /* Verify that nondeduced template arguments agree with the type
11309 obtained from argument deduction.
11313 struct A { typedef int X; };
11314 template <class T, class U> struct C {};
11315 template <class T> struct C<T, typename T::X> {};
11317 Then with the instantiation `C<A, int>', we can deduce that
11318 `T' is `A' but unify () does not check whether `typename T::X'
11320 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
11321 if (spec_args == error_mark_node
11322 /* We only need to check the innermost arguments; the other
11323 arguments will always agree. */
11324 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
11325 INNERMOST_TEMPLATE_ARGS (args)))
11328 return deduced_args;
11331 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
11332 Return the TREE_LIST node with the most specialized template, if
11333 any. If there is no most specialized template, the error_mark_node
11336 Note that this function does not look at, or modify, the
11337 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
11338 returned is one of the elements of INSTANTIATIONS, callers may
11339 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
11340 and retrieve it from the value returned. */
11343 most_specialized_instantiation (tree templates)
11347 ++processing_template_decl;
11350 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
11354 if (get_bindings (TREE_VALUE (champ),
11355 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11356 NULL_TREE, /*check_ret=*/false))
11359 if (get_bindings (TREE_VALUE (fn),
11360 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11361 NULL_TREE, /*check_ret=*/false))
11368 /* Equally specialized, move to next function. If there
11369 is no next function, nothing's most specialized. */
11370 fn = TREE_CHAIN (fn);
11378 /* Now verify that champ is better than everything earlier in the
11379 instantiation list. */
11380 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
11381 if (get_bindings (TREE_VALUE (champ),
11382 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11383 NULL_TREE, /*check_ret=*/false)
11384 || !get_bindings (TREE_VALUE (fn),
11385 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11386 NULL_TREE, /*check_ret=*/false))
11392 processing_template_decl--;
11395 return error_mark_node;
11400 /* If DECL is a specialization of some template, return the most
11401 general such template. Otherwise, returns NULL_TREE.
11403 For example, given:
11405 template <class T> struct S { template <class U> void f(U); };
11407 if TMPL is `template <class U> void S<int>::f(U)' this will return
11408 the full template. This function will not trace past partial
11409 specializations, however. For example, given in addition:
11411 template <class T> struct S<T*> { template <class U> void f(U); };
11413 if TMPL is `template <class U> void S<int*>::f(U)' this will return
11414 `template <class T> template <class U> S<T*>::f(U)'. */
11417 most_general_template (tree decl)
11419 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
11420 an immediate specialization. */
11421 if (TREE_CODE (decl) == FUNCTION_DECL)
11423 if (DECL_TEMPLATE_INFO (decl)) {
11424 decl = DECL_TI_TEMPLATE (decl);
11426 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
11427 template friend. */
11428 if (TREE_CODE (decl) != TEMPLATE_DECL)
11434 /* Look for more and more general templates. */
11435 while (DECL_TEMPLATE_INFO (decl))
11437 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
11438 (See cp-tree.h for details.) */
11439 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
11442 if (CLASS_TYPE_P (TREE_TYPE (decl))
11443 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
11446 /* Stop if we run into an explicitly specialized class template. */
11447 if (!DECL_NAMESPACE_SCOPE_P (decl)
11448 && DECL_CONTEXT (decl)
11449 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
11452 decl = DECL_TI_TEMPLATE (decl);
11458 /* Return the most specialized of the class template partial
11459 specializations of TMPL which can produce TYPE, a specialization of
11460 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
11461 a _TYPE node corresponding to the partial specialization, while the
11462 TREE_PURPOSE is the set of template arguments that must be
11463 substituted into the TREE_TYPE in order to generate TYPE.
11465 If the choice of partial specialization is ambiguous, a diagnostic
11466 is issued, and the error_mark_node is returned. If there are no
11467 partial specializations of TMPL matching TYPE, then NULL_TREE is
11471 most_specialized_class (tree type, tree tmpl)
11473 tree list = NULL_TREE;
11480 tmpl = most_general_template (tmpl);
11481 args = CLASSTYPE_TI_ARGS (type);
11482 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
11484 tree partial_spec_args;
11487 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
11488 spec_args = get_class_bindings (TREE_VALUE (t),
11493 list = tree_cons (spec_args, TREE_VALUE (t), list);
11494 TREE_TYPE (list) = TREE_TYPE (t);
11501 ambiguous_p = false;
11504 t = TREE_CHAIN (t);
11505 for (; t; t = TREE_CHAIN (t))
11507 fate = more_specialized_class (champ, t);
11514 t = TREE_CHAIN (t);
11517 ambiguous_p = true;
11526 for (t = list; t && t != champ; t = TREE_CHAIN (t))
11528 fate = more_specialized_class (champ, t);
11531 ambiguous_p = true;
11538 const char *str = "candidates are:";
11539 error ("ambiguous class template instantiation for %q#T", type);
11540 for (t = list; t; t = TREE_CHAIN (t))
11542 error ("%s %+#T", str, TREE_TYPE (t));
11545 return error_mark_node;
11551 /* Explicitly instantiate DECL. */
11554 do_decl_instantiation (tree decl, tree storage)
11556 tree result = NULL_TREE;
11559 if (!decl || decl == error_mark_node)
11560 /* An error occurred, for which grokdeclarator has already issued
11561 an appropriate message. */
11563 else if (! DECL_LANG_SPECIFIC (decl))
11565 error ("explicit instantiation of non-template %q#D", decl);
11568 else if (TREE_CODE (decl) == VAR_DECL)
11570 /* There is an asymmetry here in the way VAR_DECLs and
11571 FUNCTION_DECLs are handled by grokdeclarator. In the case of
11572 the latter, the DECL we get back will be marked as a
11573 template instantiation, and the appropriate
11574 DECL_TEMPLATE_INFO will be set up. This does not happen for
11575 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
11576 should handle VAR_DECLs as it currently handles
11578 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
11579 if (!result || TREE_CODE (result) != VAR_DECL)
11581 error ("no matching template for %qD found", decl);
11585 else if (TREE_CODE (decl) != FUNCTION_DECL)
11587 error ("explicit instantiation of %q#D", decl);
11593 /* Check for various error cases. Note that if the explicit
11594 instantiation is valid the RESULT will currently be marked as an
11595 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
11596 until we get here. */
11598 if (DECL_TEMPLATE_SPECIALIZATION (result))
11600 /* DR 259 [temp.spec].
11602 Both an explicit instantiation and a declaration of an explicit
11603 specialization shall not appear in a program unless the explicit
11604 instantiation follows a declaration of the explicit specialization.
11606 For a given set of template parameters, if an explicit
11607 instantiation of a template appears after a declaration of an
11608 explicit specialization for that template, the explicit
11609 instantiation has no effect. */
11612 else if (DECL_EXPLICIT_INSTANTIATION (result))
11616 No program shall explicitly instantiate any template more
11619 We check DECL_NOT_REALLY_EXTERN so as not to complain when
11620 the first instantiation was `extern' and the second is not,
11621 and EXTERN_P for the opposite case. */
11622 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
11623 pedwarn ("duplicate explicit instantiation of %q#D", result);
11624 /* If an "extern" explicit instantiation follows an ordinary
11625 explicit instantiation, the template is instantiated. */
11629 else if (!DECL_IMPLICIT_INSTANTIATION (result))
11631 error ("no matching template for %qD found", result);
11634 else if (!DECL_TEMPLATE_INFO (result))
11636 pedwarn ("explicit instantiation of non-template %q#D", result);
11640 if (storage == NULL_TREE)
11642 else if (storage == ridpointers[(int) RID_EXTERN])
11644 if (pedantic && !in_system_header)
11645 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
11650 error ("storage class %qD applied to template instantiation", storage);
11652 check_explicit_instantiation_namespace (result);
11653 mark_decl_instantiated (result, extern_p);
11655 instantiate_decl (result, /*defer_ok=*/1,
11656 /*expl_inst_class_mem_p=*/false);
11660 mark_class_instantiated (tree t, int extern_p)
11662 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
11663 SET_CLASSTYPE_INTERFACE_KNOWN (t);
11664 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
11665 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
11668 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
11669 rest_of_type_compilation (t, 1);
11673 /* Called from do_type_instantiation through binding_table_foreach to
11674 do recursive instantiation for the type bound in ENTRY. */
11676 bt_instantiate_type_proc (binding_entry entry, void *data)
11678 tree storage = *(tree *) data;
11680 if (IS_AGGR_TYPE (entry->type)
11681 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
11682 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
11685 /* Called from do_type_instantiation to instantiate a member
11686 (a member function or a static member variable) of an
11687 explicitly instantiated class template. */
11689 instantiate_class_member (tree decl, int extern_p)
11691 mark_decl_instantiated (decl, extern_p);
11693 instantiate_decl (decl, /*defer_ok=*/1,
11694 /*expl_inst_class_mem_p=*/true);
11697 /* Perform an explicit instantiation of template class T. STORAGE, if
11698 non-null, is the RID for extern, inline or static. COMPLAIN is
11699 nonzero if this is called from the parser, zero if called recursively,
11700 since the standard is unclear (as detailed below). */
11703 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
11708 int previous_instantiation_extern_p = 0;
11710 if (TREE_CODE (t) == TYPE_DECL)
11713 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
11715 error ("explicit instantiation of non-template type %qT", t);
11721 if (!COMPLETE_TYPE_P (t))
11723 if (complain & tf_error)
11724 error ("explicit instantiation of %q#T before definition of template",
11729 if (storage != NULL_TREE)
11731 if (pedantic && !in_system_header)
11732 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
11735 if (storage == ridpointers[(int) RID_INLINE])
11737 else if (storage == ridpointers[(int) RID_EXTERN])
11739 else if (storage == ridpointers[(int) RID_STATIC])
11743 error ("storage class %qD applied to template instantiation",
11749 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
11751 /* DR 259 [temp.spec].
11753 Both an explicit instantiation and a declaration of an explicit
11754 specialization shall not appear in a program unless the explicit
11755 instantiation follows a declaration of the explicit specialization.
11757 For a given set of template parameters, if an explicit
11758 instantiation of a template appears after a declaration of an
11759 explicit specialization for that template, the explicit
11760 instantiation has no effect. */
11763 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
11767 No program shall explicitly instantiate any template more
11770 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
11771 instantiation was `extern'. If EXTERN_P then the second is.
11772 These cases are OK. */
11773 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
11775 if (!previous_instantiation_extern_p && !extern_p
11776 && (complain & tf_error))
11777 pedwarn ("duplicate explicit instantiation of %q#T", t);
11779 /* If we've already instantiated the template, just return now. */
11780 if (!CLASSTYPE_INTERFACE_ONLY (t))
11784 check_explicit_instantiation_namespace (TYPE_NAME (t));
11785 mark_class_instantiated (t, extern_p);
11793 /* In contrast to implicit instantiation, where only the
11794 declarations, and not the definitions, of members are
11795 instantiated, we have here:
11799 The explicit instantiation of a class template specialization
11800 implies the instantiation of all of its members not
11801 previously explicitly specialized in the translation unit
11802 containing the explicit instantiation.
11804 Of course, we can't instantiate member template classes, since
11805 we don't have any arguments for them. Note that the standard
11806 is unclear on whether the instantiation of the members are
11807 *explicit* instantiations or not. However, the most natural
11808 interpretation is that it should be an explicit instantiation. */
11811 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
11812 if (TREE_CODE (tmp) == FUNCTION_DECL
11813 && DECL_TEMPLATE_INSTANTIATION (tmp))
11814 instantiate_class_member (tmp, extern_p);
11816 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
11817 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
11818 instantiate_class_member (tmp, extern_p);
11820 if (CLASSTYPE_NESTED_UTDS (t))
11821 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
11822 bt_instantiate_type_proc, &storage);
11826 /* Given a function DECL, which is a specialization of TMPL, modify
11827 DECL to be a re-instantiation of TMPL with the same template
11828 arguments. TMPL should be the template into which tsubst'ing
11829 should occur for DECL, not the most general template.
11831 One reason for doing this is a scenario like this:
11834 void f(const T&, int i);
11836 void g() { f(3, 7); }
11839 void f(const T& t, const int i) { }
11841 Note that when the template is first instantiated, with
11842 instantiate_template, the resulting DECL will have no name for the
11843 first parameter, and the wrong type for the second. So, when we go
11844 to instantiate the DECL, we regenerate it. */
11847 regenerate_decl_from_template (tree decl, tree tmpl)
11849 /* The arguments used to instantiate DECL, from the most general
11854 args = DECL_TI_ARGS (decl);
11855 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
11857 /* Make sure that we can see identifiers, and compute access
11859 push_access_scope (decl);
11861 if (TREE_CODE (decl) == FUNCTION_DECL)
11869 args_depth = TMPL_ARGS_DEPTH (args);
11870 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
11871 if (args_depth > parms_depth)
11872 args = get_innermost_template_args (args, parms_depth);
11874 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
11875 args, tf_error, NULL_TREE);
11877 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
11880 /* Merge parameter declarations. */
11881 decl_parm = skip_artificial_parms_for (decl,
11882 DECL_ARGUMENTS (decl));
11884 = skip_artificial_parms_for (code_pattern,
11885 DECL_ARGUMENTS (code_pattern));
11891 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
11892 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
11893 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
11895 parm_type = type_decays_to (parm_type);
11896 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
11897 TREE_TYPE (decl_parm) = parm_type;
11898 attributes = DECL_ATTRIBUTES (pattern_parm);
11899 if (DECL_ATTRIBUTES (decl_parm) != attributes)
11901 DECL_ATTRIBUTES (decl_parm) = attributes;
11902 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
11904 decl_parm = TREE_CHAIN (decl_parm);
11905 pattern_parm = TREE_CHAIN (pattern_parm);
11908 /* Merge additional specifiers from the CODE_PATTERN. */
11909 if (DECL_DECLARED_INLINE_P (code_pattern)
11910 && !DECL_DECLARED_INLINE_P (decl))
11911 DECL_DECLARED_INLINE_P (decl) = 1;
11912 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
11913 DECL_INLINE (decl) = 1;
11915 else if (TREE_CODE (decl) == VAR_DECL)
11916 DECL_INITIAL (decl) =
11917 tsubst_expr (DECL_INITIAL (code_pattern), args,
11918 tf_error, DECL_TI_TEMPLATE (decl),
11919 /*integral_constant_expression_p=*/false);
11921 gcc_unreachable ();
11923 pop_access_scope (decl);
11926 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
11927 substituted to get DECL. */
11930 template_for_substitution (tree decl)
11932 tree tmpl = DECL_TI_TEMPLATE (decl);
11934 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
11935 for the instantiation. This is not always the most general
11936 template. Consider, for example:
11939 struct S { template <class U> void f();
11940 template <> void f<int>(); };
11942 and an instantiation of S<double>::f<int>. We want TD to be the
11943 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11944 while (/* An instantiation cannot have a definition, so we need a
11945 more general template. */
11946 DECL_TEMPLATE_INSTANTIATION (tmpl)
11947 /* We must also deal with friend templates. Given:
11949 template <class T> struct S {
11950 template <class U> friend void f() {};
11953 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
11954 so far as the language is concerned, but that's still
11955 where we get the pattern for the instantiation from. On
11956 other hand, if the definition comes outside the class, say:
11958 template <class T> struct S {
11959 template <class U> friend void f();
11961 template <class U> friend void f() {}
11963 we don't need to look any further. That's what the check for
11964 DECL_INITIAL is for. */
11965 || (TREE_CODE (decl) == FUNCTION_DECL
11966 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
11967 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
11969 /* The present template, TD, should not be a definition. If it
11970 were a definition, we should be using it! Note that we
11971 cannot restructure the loop to just keep going until we find
11972 a template with a definition, since that might go too far if
11973 a specialization was declared, but not defined. */
11974 gcc_assert (TREE_CODE (decl) != VAR_DECL
11975 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
11977 /* Fetch the more general template. */
11978 tmpl = DECL_TI_TEMPLATE (tmpl);
11984 /* Produce the definition of D, a _DECL generated from a template. If
11985 DEFER_OK is nonzero, then we don't have to actually do the
11986 instantiation now; we just have to do it sometime. Normally it is
11987 an error if this is an explicit instantiation but D is undefined.
11988 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
11989 explicitly instantiated class template. */
11992 instantiate_decl (tree d, int defer_ok,
11993 bool expl_inst_class_mem_p)
11995 tree tmpl = DECL_TI_TEMPLATE (d);
12002 bool pattern_defined;
12004 location_t saved_loc = input_location;
12007 /* This function should only be used to instantiate templates for
12008 functions and static member variables. */
12009 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
12010 || TREE_CODE (d) == VAR_DECL);
12012 /* Variables are never deferred; if instantiation is required, they
12013 are instantiated right away. That allows for better code in the
12014 case that an expression refers to the value of the variable --
12015 if the variable has a constant value the referring expression can
12016 take advantage of that fact. */
12017 if (TREE_CODE (d) == VAR_DECL)
12020 /* Don't instantiate cloned functions. Instead, instantiate the
12021 functions they cloned. */
12022 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
12023 d = DECL_CLONED_FUNCTION (d);
12025 if (DECL_TEMPLATE_INSTANTIATED (d))
12026 /* D has already been instantiated. It might seem reasonable to
12027 check whether or not D is an explicit instantiation, and, if so,
12028 stop here. But when an explicit instantiation is deferred
12029 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
12030 is set, even though we still need to do the instantiation. */
12033 /* If we already have a specialization of this declaration, then
12034 there's no reason to instantiate it. Note that
12035 retrieve_specialization gives us both instantiations and
12036 specializations, so we must explicitly check
12037 DECL_TEMPLATE_SPECIALIZATION. */
12038 gen_tmpl = most_general_template (tmpl);
12039 gen_args = DECL_TI_ARGS (d);
12040 spec = retrieve_specialization (gen_tmpl, gen_args,
12041 /*class_specializations_p=*/false);
12042 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
12045 /* This needs to happen before any tsubsting. */
12046 if (! push_tinst_level (d))
12049 timevar_push (TV_PARSE);
12051 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
12052 for the instantiation. */
12053 td = template_for_substitution (d);
12054 code_pattern = DECL_TEMPLATE_RESULT (td);
12056 /* We should never be trying to instantiate a member of a class
12057 template or partial specialization. */
12058 gcc_assert (d != code_pattern);
12060 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
12061 || DECL_TEMPLATE_SPECIALIZATION (td))
12062 /* In the case of a friend template whose definition is provided
12063 outside the class, we may have too many arguments. Drop the
12064 ones we don't need. The same is true for specializations. */
12065 args = get_innermost_template_args
12066 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
12070 if (TREE_CODE (d) == FUNCTION_DECL)
12071 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
12073 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
12075 /* We may be in the middle of deferred access check. Disable it now. */
12076 push_deferring_access_checks (dk_no_deferred);
12078 /* Unless an explicit instantiation directive has already determined
12079 the linkage of D, remember that a definition is available for
12081 if (pattern_defined
12082 && !DECL_INTERFACE_KNOWN (d)
12083 && !DECL_NOT_REALLY_EXTERN (d))
12084 mark_definable (d);
12086 input_location = DECL_SOURCE_LOCATION (d);
12088 /* If D is a member of an explicitly instantiated class template,
12089 and no definition is available, treat it like an implicit
12091 if (!pattern_defined && expl_inst_class_mem_p
12092 && DECL_EXPLICIT_INSTANTIATION (d))
12094 DECL_NOT_REALLY_EXTERN (d) = 0;
12095 DECL_INTERFACE_KNOWN (d) = 0;
12096 SET_DECL_IMPLICIT_INSTANTIATION (d);
12101 /* Recheck the substitutions to obtain any warning messages
12102 about ignoring cv qualifiers. */
12103 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
12104 tree type = TREE_TYPE (gen);
12106 /* Make sure that we can see identifiers, and compute access
12107 correctly. D is already the target FUNCTION_DECL with the
12109 push_access_scope (d);
12111 if (TREE_CODE (gen) == FUNCTION_DECL)
12113 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
12114 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
12115 tf_warning_or_error, d);
12116 /* Don't simply tsubst the function type, as that will give
12117 duplicate warnings about poor parameter qualifications.
12118 The function arguments are the same as the decl_arguments
12119 without the top level cv qualifiers. */
12120 type = TREE_TYPE (type);
12122 tsubst (type, gen_args, tf_warning_or_error, d);
12124 pop_access_scope (d);
12127 /* Check to see whether we know that this template will be
12128 instantiated in some other file, as with "extern template"
12130 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
12131 /* In general, we do not instantiate such templates... */
12133 /* ... but we instantiate inline functions so that we can inline
12135 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
12136 /* ... we instantiate static data members whose values are
12137 needed in integral constant expressions. */
12138 && ! (TREE_CODE (d) == VAR_DECL
12139 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
12141 /* Defer all other templates, unless we have been explicitly
12142 forbidden from doing so. */
12143 if (/* If there is no definition, we cannot instantiate the
12146 /* If it's OK to postpone instantiation, do so. */
12148 /* If this is a static data member that will be defined
12149 elsewhere, we don't want to instantiate the entire data
12150 member, but we do want to instantiate the initializer so that
12151 we can substitute that elsewhere. */
12152 || (external_p && TREE_CODE (d) == VAR_DECL))
12154 /* The definition of the static data member is now required so
12155 we must substitute the initializer. */
12156 if (TREE_CODE (d) == VAR_DECL
12157 && !DECL_INITIAL (d)
12158 && DECL_INITIAL (code_pattern))
12163 ns = decl_namespace_context (d);
12164 push_nested_namespace (ns);
12165 push_nested_class (DECL_CONTEXT (d));
12166 init = tsubst_expr (DECL_INITIAL (code_pattern),
12168 tf_warning_or_error, NULL_TREE,
12169 /*integral_constant_expression_p=*/false);
12170 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
12171 /*asmspec_tree=*/NULL_TREE,
12172 LOOKUP_ONLYCONVERTING);
12173 pop_nested_class ();
12174 pop_nested_namespace (ns);
12177 /* We restore the source position here because it's used by
12178 add_pending_template. */
12179 input_location = saved_loc;
12181 if (at_eof && !pattern_defined
12182 && DECL_EXPLICIT_INSTANTIATION (d))
12185 The definition of a non-exported function template, a
12186 non-exported member function template, or a non-exported
12187 member function or static data member of a class template
12188 shall be present in every translation unit in which it is
12189 explicitly instantiated. */
12191 ("explicit instantiation of %qD but no definition available", d);
12193 /* ??? Historically, we have instantiated inline functions, even
12194 when marked as "extern template". */
12195 if (!(external_p && TREE_CODE (d) == VAR_DECL))
12196 add_pending_template (d);
12199 /* Tell the repository that D is available in this translation unit
12200 -- and see if it is supposed to be instantiated here. */
12201 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
12203 /* In a PCH file, despite the fact that the repository hasn't
12204 requested instantiation in the PCH it is still possible that
12205 an instantiation will be required in a file that includes the
12208 add_pending_template (d);
12209 /* Instantiate inline functions so that the inliner can do its
12210 job, even though we'll not be emitting a copy of this
12212 if (!(TREE_CODE (d) == FUNCTION_DECL
12213 && flag_inline_trees
12214 && DECL_DECLARED_INLINE_P (d)))
12218 need_push = !cfun || !global_bindings_p ();
12220 push_to_top_level ();
12222 /* Mark D as instantiated so that recursive calls to
12223 instantiate_decl do not try to instantiate it again. */
12224 DECL_TEMPLATE_INSTANTIATED (d) = 1;
12226 /* Regenerate the declaration in case the template has been modified
12227 by a subsequent redeclaration. */
12228 regenerate_decl_from_template (d, td);
12230 /* We already set the file and line above. Reset them now in case
12231 they changed as a result of calling regenerate_decl_from_template. */
12232 input_location = DECL_SOURCE_LOCATION (d);
12234 if (TREE_CODE (d) == VAR_DECL)
12238 /* Clear out DECL_RTL; whatever was there before may not be right
12239 since we've reset the type of the declaration. */
12240 SET_DECL_RTL (d, NULL_RTX);
12241 DECL_IN_AGGR_P (d) = 0;
12243 /* The initializer is placed in DECL_INITIAL by
12244 regenerate_decl_from_template. Pull it out so that
12245 finish_decl can process it. */
12246 init = DECL_INITIAL (d);
12247 DECL_INITIAL (d) = NULL_TREE;
12248 DECL_INITIALIZED_P (d) = 0;
12250 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
12251 initializer. That function will defer actual emission until
12252 we have a chance to determine linkage. */
12253 DECL_EXTERNAL (d) = 0;
12255 /* Enter the scope of D so that access-checking works correctly. */
12256 push_nested_class (DECL_CONTEXT (d));
12257 finish_decl (d, init, NULL_TREE);
12258 pop_nested_class ();
12260 else if (TREE_CODE (d) == FUNCTION_DECL)
12262 htab_t saved_local_specializations;
12267 /* Save away the current list, in case we are instantiating one
12268 template from within the body of another. */
12269 saved_local_specializations = local_specializations;
12271 /* Set up the list of local specializations. */
12272 local_specializations = htab_create (37,
12273 hash_local_specialization,
12274 eq_local_specializations,
12277 /* Set up context. */
12278 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
12280 /* Create substitution entries for the parameters. */
12281 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
12282 tmpl_parm = DECL_ARGUMENTS (subst_decl);
12283 spec_parm = DECL_ARGUMENTS (d);
12284 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
12286 register_local_specialization (spec_parm, tmpl_parm);
12287 spec_parm = skip_artificial_parms_for (d, spec_parm);
12288 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
12292 register_local_specialization (spec_parm, tmpl_parm);
12293 tmpl_parm = TREE_CHAIN (tmpl_parm);
12294 spec_parm = TREE_CHAIN (spec_parm);
12296 gcc_assert (!spec_parm);
12298 /* Substitute into the body of the function. */
12299 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
12300 tf_warning_or_error, tmpl,
12301 /*integral_constant_expression_p=*/false);
12303 /* We don't need the local specializations any more. */
12304 htab_delete (local_specializations);
12305 local_specializations = saved_local_specializations;
12307 /* Finish the function. */
12308 d = finish_function (0);
12309 expand_or_defer_fn (d);
12312 /* We're not deferring instantiation any more. */
12313 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
12316 pop_from_top_level ();
12319 input_location = saved_loc;
12320 pop_deferring_access_checks ();
12321 pop_tinst_level ();
12323 timevar_pop (TV_PARSE);
12328 /* Run through the list of templates that we wish we could
12329 instantiate, and instantiate any we can. RETRIES is the
12330 number of times we retry pending template instantiation. */
12333 instantiate_pending_templates (int retries)
12336 tree last = NULL_TREE;
12338 location_t saved_loc = input_location;
12339 int saved_in_system_header = in_system_header;
12341 /* Instantiating templates may trigger vtable generation. This in turn
12342 may require further template instantiations. We place a limit here
12343 to avoid infinite loop. */
12344 if (pending_templates && retries >= max_tinst_depth)
12346 tree decl = TREE_VALUE (pending_templates);
12348 error ("template instantiation depth exceeds maximum of %d"
12349 " instantiating %q+D, possibly from virtual table generation"
12350 " (use -ftemplate-depth-NN to increase the maximum)",
12351 max_tinst_depth, decl);
12352 if (TREE_CODE (decl) == FUNCTION_DECL)
12353 /* Pretend that we defined it. */
12354 DECL_INITIAL (decl) = error_mark_node;
12362 t = &pending_templates;
12365 tree instantiation = TREE_VALUE (*t);
12367 reopen_tinst_level (TREE_PURPOSE (*t));
12369 if (TYPE_P (instantiation))
12373 if (!COMPLETE_TYPE_P (instantiation))
12375 instantiate_class_template (instantiation);
12376 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
12377 for (fn = TYPE_METHODS (instantiation);
12379 fn = TREE_CHAIN (fn))
12380 if (! DECL_ARTIFICIAL (fn))
12381 instantiate_decl (fn,
12383 /*expl_inst_class_mem_p=*/false);
12384 if (COMPLETE_TYPE_P (instantiation))
12388 if (COMPLETE_TYPE_P (instantiation))
12389 /* If INSTANTIATION has been instantiated, then we don't
12390 need to consider it again in the future. */
12391 *t = TREE_CHAIN (*t);
12395 t = &TREE_CHAIN (*t);
12400 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
12401 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
12404 = instantiate_decl (instantiation,
12406 /*expl_inst_class_mem_p=*/false);
12407 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
12411 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
12412 || DECL_TEMPLATE_INSTANTIATED (instantiation))
12413 /* If INSTANTIATION has been instantiated, then we don't
12414 need to consider it again in the future. */
12415 *t = TREE_CHAIN (*t);
12419 t = &TREE_CHAIN (*t);
12423 current_tinst_level = NULL_TREE;
12425 last_pending_template = last;
12427 while (reconsider);
12429 input_location = saved_loc;
12430 in_system_header = saved_in_system_header;
12433 /* Substitute ARGVEC into T, which is a list of initializers for
12434 either base class or a non-static data member. The TREE_PURPOSEs
12435 are DECLs, and the TREE_VALUEs are the initializer values. Used by
12436 instantiate_decl. */
12439 tsubst_initializer_list (tree t, tree argvec)
12441 tree inits = NULL_TREE;
12443 for (; t; t = TREE_CHAIN (t))
12448 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_warning_or_error,
12450 decl = expand_member_init (decl);
12451 if (decl && !DECL_P (decl))
12452 in_base_initializer = 1;
12454 init = tsubst_expr (TREE_VALUE (t), argvec, tf_warning_or_error,
12456 /*integral_constant_expression_p=*/false);
12457 in_base_initializer = 0;
12461 init = build_tree_list (decl, init);
12462 TREE_CHAIN (init) = inits;
12469 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
12472 set_current_access_from_decl (tree decl)
12474 if (TREE_PRIVATE (decl))
12475 current_access_specifier = access_private_node;
12476 else if (TREE_PROTECTED (decl))
12477 current_access_specifier = access_protected_node;
12479 current_access_specifier = access_public_node;
12482 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
12483 is the instantiation (which should have been created with
12484 start_enum) and ARGS are the template arguments to use. */
12487 tsubst_enum (tree tag, tree newtag, tree args)
12491 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
12496 decl = TREE_VALUE (e);
12497 /* Note that in a template enum, the TREE_VALUE is the
12498 CONST_DECL, not the corresponding INTEGER_CST. */
12499 value = tsubst_expr (DECL_INITIAL (decl),
12500 args, tf_warning_or_error, NULL_TREE,
12501 /*integral_constant_expression_p=*/true);
12503 /* Give this enumeration constant the correct access. */
12504 set_current_access_from_decl (decl);
12506 /* Actually build the enumerator itself. */
12507 build_enumerator (DECL_NAME (decl), value, newtag);
12510 finish_enum (newtag);
12511 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
12512 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
12515 /* DECL is a FUNCTION_DECL that is a template specialization. Return
12516 its type -- but without substituting the innermost set of template
12517 arguments. So, innermost set of template parameters will appear in
12521 get_mostly_instantiated_function_type (tree decl)
12529 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
12530 targs = DECL_TI_ARGS (decl);
12531 tparms = DECL_TEMPLATE_PARMS (tmpl);
12532 parm_depth = TMPL_PARMS_DEPTH (tparms);
12534 /* There should be as many levels of arguments as there are levels
12536 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
12538 fn_type = TREE_TYPE (tmpl);
12540 if (parm_depth == 1)
12541 /* No substitution is necessary. */
12545 int i, save_access_control;
12548 /* Replace the innermost level of the TARGS with NULL_TREEs to
12549 let tsubst know not to substitute for those parameters. */
12550 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
12551 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
12552 SET_TMPL_ARGS_LEVEL (partial_args, i,
12553 TMPL_ARGS_LEVEL (targs, i));
12554 SET_TMPL_ARGS_LEVEL (partial_args,
12555 TMPL_ARGS_DEPTH (targs),
12556 make_tree_vec (DECL_NTPARMS (tmpl)));
12558 /* Disable access control as this function is used only during
12560 save_access_control = flag_access_control;
12561 flag_access_control = 0;
12563 ++processing_template_decl;
12564 /* Now, do the (partial) substitution to figure out the
12565 appropriate function type. */
12566 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
12567 --processing_template_decl;
12569 /* Substitute into the template parameters to obtain the real
12570 innermost set of parameters. This step is important if the
12571 innermost set of template parameters contains value
12572 parameters whose types depend on outer template parameters. */
12573 TREE_VEC_LENGTH (partial_args)--;
12574 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
12576 flag_access_control = save_access_control;
12582 /* Return truthvalue if we're processing a template different from
12583 the last one involved in diagnostics. */
12585 problematic_instantiation_changed (void)
12587 return last_template_error_tick != tinst_level_tick;
12590 /* Remember current template involved in diagnostics. */
12592 record_last_problematic_instantiation (void)
12594 last_template_error_tick = tinst_level_tick;
12598 current_instantiation (void)
12600 return current_tinst_level;
12603 /* [temp.param] Check that template non-type parm TYPE is of an allowable
12604 type. Return zero for ok, nonzero for disallowed. Issue error and
12605 warning messages under control of COMPLAIN. */
12608 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
12610 if (INTEGRAL_TYPE_P (type))
12612 else if (POINTER_TYPE_P (type))
12614 else if (TYPE_PTR_TO_MEMBER_P (type))
12616 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
12618 else if (TREE_CODE (type) == TYPENAME_TYPE)
12621 if (complain & tf_error)
12622 error ("%q#T is not a valid type for a template constant parameter", type);
12626 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
12627 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
12630 dependent_type_p_r (tree type)
12636 A type is dependent if it is:
12638 -- a template parameter. Template template parameters are types
12639 for us (since TYPE_P holds true for them) so we handle
12641 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
12642 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
12644 /* -- a qualified-id with a nested-name-specifier which contains a
12645 class-name that names a dependent type or whose unqualified-id
12646 names a dependent type. */
12647 if (TREE_CODE (type) == TYPENAME_TYPE)
12649 /* -- a cv-qualified type where the cv-unqualified type is
12651 type = TYPE_MAIN_VARIANT (type);
12652 /* -- a compound type constructed from any dependent type. */
12653 if (TYPE_PTR_TO_MEMBER_P (type))
12654 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
12655 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
12657 else if (TREE_CODE (type) == POINTER_TYPE
12658 || TREE_CODE (type) == REFERENCE_TYPE)
12659 return dependent_type_p (TREE_TYPE (type));
12660 else if (TREE_CODE (type) == FUNCTION_TYPE
12661 || TREE_CODE (type) == METHOD_TYPE)
12665 if (dependent_type_p (TREE_TYPE (type)))
12667 for (arg_type = TYPE_ARG_TYPES (type);
12669 arg_type = TREE_CHAIN (arg_type))
12670 if (dependent_type_p (TREE_VALUE (arg_type)))
12674 /* -- an array type constructed from any dependent type or whose
12675 size is specified by a constant expression that is
12676 value-dependent. */
12677 if (TREE_CODE (type) == ARRAY_TYPE)
12679 if (TYPE_DOMAIN (type)
12680 && ((value_dependent_expression_p
12681 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12682 || (type_dependent_expression_p
12683 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
12685 return dependent_type_p (TREE_TYPE (type));
12688 /* -- a template-id in which either the template name is a template
12690 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
12692 /* ... or any of the template arguments is a dependent type or
12693 an expression that is type-dependent or value-dependent. */
12694 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
12695 && (any_dependent_template_arguments_p
12696 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
12699 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
12700 expression is not type-dependent, then it should already been
12702 if (TREE_CODE (type) == TYPEOF_TYPE)
12705 /* The standard does not specifically mention types that are local
12706 to template functions or local classes, but they should be
12707 considered dependent too. For example:
12709 template <int I> void f() {
12714 The size of `E' cannot be known until the value of `I' has been
12715 determined. Therefore, `E' must be considered dependent. */
12716 scope = TYPE_CONTEXT (type);
12717 if (scope && TYPE_P (scope))
12718 return dependent_type_p (scope);
12719 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12720 return type_dependent_expression_p (scope);
12722 /* Other types are non-dependent. */
12726 /* Returns TRUE if TYPE is dependent, in the sense of
12727 [temp.dep.type]. */
12730 dependent_type_p (tree type)
12732 /* If there are no template parameters in scope, then there can't be
12733 any dependent types. */
12734 if (!processing_template_decl)
12736 /* If we are not processing a template, then nobody should be
12737 providing us with a dependent type. */
12739 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
12743 /* If the type is NULL, we have not computed a type for the entity
12744 in question; in that case, the type is dependent. */
12748 /* Erroneous types can be considered non-dependent. */
12749 if (type == error_mark_node)
12752 /* If we have not already computed the appropriate value for TYPE,
12754 if (!TYPE_DEPENDENT_P_VALID (type))
12756 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
12757 TYPE_DEPENDENT_P_VALID (type) = 1;
12760 return TYPE_DEPENDENT_P (type);
12763 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
12766 dependent_scope_ref_p (tree expression, bool criterion (tree))
12771 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
12773 if (!TYPE_P (TREE_OPERAND (expression, 0)))
12776 scope = TREE_OPERAND (expression, 0);
12777 name = TREE_OPERAND (expression, 1);
12781 An id-expression is type-dependent if it contains a
12782 nested-name-specifier that contains a class-name that names a
12784 /* The suggested resolution to Core Issue 2 implies that if the
12785 qualifying type is the current class, then we must peek
12788 && currently_open_class (scope)
12789 && !criterion (name))
12791 if (dependent_type_p (scope))
12797 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
12798 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
12802 value_dependent_expression_p (tree expression)
12804 if (!processing_template_decl)
12807 /* A name declared with a dependent type. */
12808 if (DECL_P (expression) && type_dependent_expression_p (expression))
12811 switch (TREE_CODE (expression))
12813 case IDENTIFIER_NODE:
12814 /* A name that has not been looked up -- must be dependent. */
12817 case TEMPLATE_PARM_INDEX:
12818 /* A non-type template parm. */
12822 /* A non-type template parm. */
12823 if (DECL_TEMPLATE_PARM_P (expression))
12828 /* A constant with integral or enumeration type and is initialized
12829 with an expression that is value-dependent. */
12830 if (DECL_INITIAL (expression)
12831 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
12832 && value_dependent_expression_p (DECL_INITIAL (expression)))
12836 case DYNAMIC_CAST_EXPR:
12837 case STATIC_CAST_EXPR:
12838 case CONST_CAST_EXPR:
12839 case REINTERPRET_CAST_EXPR:
12841 /* These expressions are value-dependent if the type to which
12842 the cast occurs is dependent or the expression being casted
12843 is value-dependent. */
12845 tree type = TREE_TYPE (expression);
12847 if (dependent_type_p (type))
12850 /* A functional cast has a list of operands. */
12851 expression = TREE_OPERAND (expression, 0);
12854 /* If there are no operands, it must be an expression such
12855 as "int()". This should not happen for aggregate types
12856 because it would form non-constant expressions. */
12857 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
12862 if (TREE_CODE (expression) == TREE_LIST)
12864 for (; expression; expression = TREE_CHAIN (expression))
12865 if (value_dependent_expression_p (TREE_VALUE (expression)))
12870 return value_dependent_expression_p (expression);
12875 /* A `sizeof' expression is value-dependent if the operand is
12877 expression = TREE_OPERAND (expression, 0);
12878 if (TYPE_P (expression))
12879 return dependent_type_p (expression);
12880 return type_dependent_expression_p (expression);
12883 return dependent_scope_ref_p (expression, value_dependent_expression_p);
12885 case COMPONENT_REF:
12886 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
12887 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
12890 /* A CALL_EXPR may appear in a constant expression if it is a
12891 call to a builtin function, e.g., __builtin_constant_p. All
12892 such calls are value-dependent. */
12896 /* A constant expression is value-dependent if any subexpression is
12897 value-dependent. */
12898 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
12900 case tcc_reference:
12902 return (value_dependent_expression_p
12903 (TREE_OPERAND (expression, 0)));
12905 case tcc_comparison:
12907 return ((value_dependent_expression_p
12908 (TREE_OPERAND (expression, 0)))
12909 || (value_dependent_expression_p
12910 (TREE_OPERAND (expression, 1))));
12912 case tcc_expression:
12915 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
12916 /* In some cases, some of the operands may be missing.
12917 (For example, in the case of PREDECREMENT_EXPR, the
12918 amount to increment by may be missing.) That doesn't
12919 make the expression dependent. */
12920 if (TREE_OPERAND (expression, i)
12921 && (value_dependent_expression_p
12922 (TREE_OPERAND (expression, i))))
12932 /* The expression is not value-dependent. */
12936 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
12937 [temp.dep.expr]. */
12940 type_dependent_expression_p (tree expression)
12942 if (!processing_template_decl)
12945 if (expression == error_mark_node)
12948 /* An unresolved name is always dependent. */
12949 if (TREE_CODE (expression) == IDENTIFIER_NODE
12950 || TREE_CODE (expression) == USING_DECL)
12953 /* Some expression forms are never type-dependent. */
12954 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
12955 || TREE_CODE (expression) == SIZEOF_EXPR
12956 || TREE_CODE (expression) == ALIGNOF_EXPR
12957 || TREE_CODE (expression) == TYPEID_EXPR
12958 || TREE_CODE (expression) == DELETE_EXPR
12959 || TREE_CODE (expression) == VEC_DELETE_EXPR
12960 || TREE_CODE (expression) == THROW_EXPR)
12963 /* The types of these expressions depends only on the type to which
12964 the cast occurs. */
12965 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
12966 || TREE_CODE (expression) == STATIC_CAST_EXPR
12967 || TREE_CODE (expression) == CONST_CAST_EXPR
12968 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
12969 || TREE_CODE (expression) == CAST_EXPR)
12970 return dependent_type_p (TREE_TYPE (expression));
12972 /* The types of these expressions depends only on the type created
12973 by the expression. */
12974 if (TREE_CODE (expression) == NEW_EXPR
12975 || TREE_CODE (expression) == VEC_NEW_EXPR)
12977 /* For NEW_EXPR tree nodes created inside a template, either
12978 the object type itself or a TREE_LIST may appear as the
12980 tree type = TREE_OPERAND (expression, 1);
12981 if (TREE_CODE (type) == TREE_LIST)
12982 /* This is an array type. We need to check array dimensions
12984 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
12985 || value_dependent_expression_p
12986 (TREE_OPERAND (TREE_VALUE (type), 1));
12988 return dependent_type_p (type);
12991 if (TREE_CODE (expression) == SCOPE_REF
12992 && dependent_scope_ref_p (expression,
12993 type_dependent_expression_p))
12996 if (TREE_CODE (expression) == FUNCTION_DECL
12997 && DECL_LANG_SPECIFIC (expression)
12998 && DECL_TEMPLATE_INFO (expression)
12999 && (any_dependent_template_arguments_p
13000 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
13003 if (TREE_CODE (expression) == TEMPLATE_DECL
13004 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
13007 if (TREE_TYPE (expression) == unknown_type_node)
13009 if (TREE_CODE (expression) == ADDR_EXPR)
13010 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
13011 if (TREE_CODE (expression) == COMPONENT_REF
13012 || TREE_CODE (expression) == OFFSET_REF)
13014 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
13016 expression = TREE_OPERAND (expression, 1);
13017 if (TREE_CODE (expression) == IDENTIFIER_NODE)
13020 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
13021 if (TREE_CODE (expression) == SCOPE_REF)
13024 if (TREE_CODE (expression) == BASELINK)
13025 expression = BASELINK_FUNCTIONS (expression);
13027 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
13029 if (any_dependent_template_arguments_p
13030 (TREE_OPERAND (expression, 1)))
13032 expression = TREE_OPERAND (expression, 0);
13034 gcc_assert (TREE_CODE (expression) == OVERLOAD
13035 || TREE_CODE (expression) == FUNCTION_DECL);
13039 if (type_dependent_expression_p (OVL_CURRENT (expression)))
13041 expression = OVL_NEXT (expression);
13046 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
13048 return (dependent_type_p (TREE_TYPE (expression)));
13051 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
13052 contains a type-dependent expression. */
13055 any_type_dependent_arguments_p (tree args)
13059 tree arg = TREE_VALUE (args);
13061 if (type_dependent_expression_p (arg))
13063 args = TREE_CHAIN (args);
13068 /* Returns TRUE if the ARG (a template argument) is dependent. */
13071 dependent_template_arg_p (tree arg)
13073 if (!processing_template_decl)
13076 if (TREE_CODE (arg) == TEMPLATE_DECL
13077 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
13078 return dependent_template_p (arg);
13079 else if (TYPE_P (arg))
13080 return dependent_type_p (arg);
13082 return (type_dependent_expression_p (arg)
13083 || value_dependent_expression_p (arg));
13086 /* Returns true if ARGS (a collection of template arguments) contains
13087 any dependent arguments. */
13090 any_dependent_template_arguments_p (tree args)
13097 if (args == error_mark_node)
13100 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
13102 tree level = TMPL_ARGS_LEVEL (args, i + 1);
13103 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
13104 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
13111 /* Returns TRUE if the template TMPL is dependent. */
13114 dependent_template_p (tree tmpl)
13116 if (TREE_CODE (tmpl) == OVERLOAD)
13120 if (dependent_template_p (OVL_FUNCTION (tmpl)))
13122 tmpl = OVL_CHAIN (tmpl);
13127 /* Template template parameters are dependent. */
13128 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
13129 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
13131 /* So are names that have not been looked up. */
13132 if (TREE_CODE (tmpl) == SCOPE_REF
13133 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
13135 /* So are member templates of dependent classes. */
13136 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
13137 return dependent_type_p (DECL_CONTEXT (tmpl));
13141 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
13144 dependent_template_id_p (tree tmpl, tree args)
13146 return (dependent_template_p (tmpl)
13147 || any_dependent_template_arguments_p (args));
13150 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
13151 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
13152 can be found. Note that this function peers inside uninstantiated
13153 templates and therefore should be used only in extremely limited
13154 situations. ONLY_CURRENT_P restricts this peering to the currently
13155 open classes hierarchy (which is required when comparing types). */
13158 resolve_typename_type (tree type, bool only_current_p)
13166 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
13168 scope = TYPE_CONTEXT (type);
13169 name = TYPE_IDENTIFIER (type);
13171 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
13172 it first before we can figure out what NAME refers to. */
13173 if (TREE_CODE (scope) == TYPENAME_TYPE)
13174 scope = resolve_typename_type (scope, only_current_p);
13175 /* If we don't know what SCOPE refers to, then we cannot resolve the
13177 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
13178 return error_mark_node;
13179 /* If the SCOPE is a template type parameter, we have no way of
13180 resolving the name. */
13181 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
13183 /* If the SCOPE is not the current instantiation, there's no reason
13184 to look inside it. */
13185 if (only_current_p && !currently_open_class (scope))
13186 return error_mark_node;
13187 /* If SCOPE is a partial instantiation, it will not have a valid
13188 TYPE_FIELDS list, so use the original template. */
13189 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
13190 /* Enter the SCOPE so that name lookup will be resolved as if we
13191 were in the class definition. In particular, SCOPE will no
13192 longer be considered a dependent type. */
13193 pushed_scope = push_scope (scope);
13194 /* Look up the declaration. */
13195 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
13196 /* Obtain the set of qualifiers applied to the TYPE. */
13197 quals = cp_type_quals (type);
13198 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
13199 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
13201 type = error_mark_node;
13202 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
13203 && TREE_CODE (decl) == TYPE_DECL)
13204 type = TREE_TYPE (decl);
13205 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
13206 && DECL_CLASS_TEMPLATE_P (decl))
13210 /* Obtain the template and the arguments. */
13211 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
13212 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
13213 /* Instantiate the template. */
13214 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
13215 /*entering_scope=*/0, tf_error | tf_user);
13218 type = error_mark_node;
13219 /* Qualify the resulting type. */
13220 if (type != error_mark_node && quals)
13221 type = cp_build_qualified_type (type, quals);
13222 /* Leave the SCOPE. */
13224 pop_scope (pushed_scope);
13229 /* EXPR is an expression which is not type-dependent. Return a proxy
13230 for EXPR that can be used to compute the types of larger
13231 expressions containing EXPR. */
13234 build_non_dependent_expr (tree expr)
13238 /* Preserve null pointer constants so that the type of things like
13239 "p == 0" where "p" is a pointer can be determined. */
13240 if (null_ptr_cst_p (expr))
13242 /* Preserve OVERLOADs; the functions must be available to resolve
13245 if (TREE_CODE (inner_expr) == ADDR_EXPR)
13246 inner_expr = TREE_OPERAND (inner_expr, 0);
13247 if (TREE_CODE (inner_expr) == COMPONENT_REF)
13248 inner_expr = TREE_OPERAND (inner_expr, 1);
13249 if (is_overloaded_fn (inner_expr)
13250 || TREE_CODE (inner_expr) == OFFSET_REF)
13252 /* There is no need to return a proxy for a variable. */
13253 if (TREE_CODE (expr) == VAR_DECL)
13255 /* Preserve string constants; conversions from string constants to
13256 "char *" are allowed, even though normally a "const char *"
13257 cannot be used to initialize a "char *". */
13258 if (TREE_CODE (expr) == STRING_CST)
13260 /* Preserve arithmetic constants, as an optimization -- there is no
13261 reason to create a new node. */
13262 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
13264 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
13265 There is at least one place where we want to know that a
13266 particular expression is a throw-expression: when checking a ?:
13267 expression, there are special rules if the second or third
13268 argument is a throw-expression. */
13269 if (TREE_CODE (expr) == THROW_EXPR)
13272 if (TREE_CODE (expr) == COND_EXPR)
13273 return build3 (COND_EXPR,
13275 TREE_OPERAND (expr, 0),
13276 (TREE_OPERAND (expr, 1)
13277 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
13278 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
13279 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
13280 if (TREE_CODE (expr) == COMPOUND_EXPR
13281 && !COMPOUND_EXPR_OVERLOADED (expr))
13282 return build2 (COMPOUND_EXPR,
13284 TREE_OPERAND (expr, 0),
13285 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
13287 /* If the type is unknown, it can't really be non-dependent */
13288 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
13290 /* Otherwise, build a NON_DEPENDENT_EXPR.
13292 REFERENCE_TYPEs are not stripped for expressions in templates
13293 because doing so would play havoc with mangling. Consider, for
13296 template <typename T> void f<T& g>() { g(); }
13298 In the body of "f", the expression for "g" will have
13299 REFERENCE_TYPE, even though the standard says that it should
13300 not. The reason is that we must preserve the syntactic form of
13301 the expression so that mangling (say) "f<g>" inside the body of
13302 "f" works out correctly. Therefore, the REFERENCE_TYPE is
13304 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
13307 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
13308 Return a new TREE_LIST with the various arguments replaced with
13309 equivalent non-dependent expressions. */
13312 build_non_dependent_args (tree args)
13317 new_args = NULL_TREE;
13318 for (a = args; a; a = TREE_CHAIN (a))
13319 new_args = tree_cons (NULL_TREE,
13320 build_non_dependent_expr (TREE_VALUE (a)),
13322 return nreverse (new_args);
13325 #include "gt-cp-pt.h"