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 bool 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 /* TYPE is a class type. Returns true if TYPE is an explicitly
1320 specialized class. */
1323 explicit_class_specialization_p (tree type)
1325 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1327 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1330 /* Print the list of candidate FNS in an error message. */
1333 print_candidates (tree fns)
1337 const char *str = "candidates are:";
1339 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1343 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1344 error ("%s %+#D", str, OVL_CURRENT (f));
1349 /* Returns the template (one of the functions given by TEMPLATE_ID)
1350 which can be specialized to match the indicated DECL with the
1351 explicit template args given in TEMPLATE_ID. The DECL may be
1352 NULL_TREE if none is available. In that case, the functions in
1353 TEMPLATE_ID are non-members.
1355 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1356 specialization of a member template.
1358 The TEMPLATE_COUNT is the number of references to qualifying
1359 template classes that appeared in the name of the function. See
1360 check_explicit_specialization for a more accurate description.
1362 TSK indicates what kind of template declaration (if any) is being
1363 declared. TSK_TEMPLATE indicates that the declaration given by
1364 DECL, though a FUNCTION_DECL, has template parameters, and is
1365 therefore a template function.
1367 The template args (those explicitly specified and those deduced)
1368 are output in a newly created vector *TARGS_OUT.
1370 If it is impossible to determine the result, an error message is
1371 issued. The error_mark_node is returned to indicate failure. */
1374 determine_specialization (tree template_id,
1377 int need_member_template,
1383 tree explicit_targs;
1384 tree candidates = NULL_TREE;
1385 /* A TREE_LIST of templates of which DECL may be a specialization.
1386 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1387 corresponding TREE_PURPOSE is the set of template arguments that,
1388 when used to instantiate the template, would produce a function
1389 with the signature of DECL. */
1390 tree templates = NULL_TREE;
1392 struct cp_binding_level *b;
1394 *targs_out = NULL_TREE;
1396 if (template_id == error_mark_node || decl == error_mark_node)
1397 return error_mark_node;
1399 fns = TREE_OPERAND (template_id, 0);
1400 explicit_targs = TREE_OPERAND (template_id, 1);
1402 if (fns == error_mark_node)
1403 return error_mark_node;
1405 /* Check for baselinks. */
1406 if (BASELINK_P (fns))
1407 fns = BASELINK_FUNCTIONS (fns);
1409 if (!is_overloaded_fn (fns))
1411 error ("%qD is not a function template", fns);
1412 return error_mark_node;
1415 /* Count the number of template headers specified for this
1418 for (b = current_binding_level;
1419 b->kind == sk_template_parms;
1423 for (; fns; fns = OVL_NEXT (fns))
1425 tree fn = OVL_CURRENT (fns);
1427 if (TREE_CODE (fn) == TEMPLATE_DECL)
1429 tree decl_arg_types;
1432 /* In case of explicit specialization, we need to check if
1433 the number of template headers appearing in the specialization
1434 is correct. This is usually done in check_explicit_specialization,
1435 but the check done there cannot be exhaustive when specializing
1436 member functions. Consider the following code:
1438 template <> void A<int>::f(int);
1439 template <> template <> void A<int>::f(int);
1441 Assuming that A<int> is not itself an explicit specialization
1442 already, the first line specializes "f" which is a non-template
1443 member function, whilst the second line specializes "f" which
1444 is a template member function. So both lines are syntactically
1445 correct, and check_explicit_specialization does not reject
1448 Here, we can do better, as we are matching the specialization
1449 against the declarations. We count the number of template
1450 headers, and we check if they match TEMPLATE_COUNT + 1
1451 (TEMPLATE_COUNT is the number of qualifying template classes,
1452 plus there must be another header for the member template
1455 Notice that if header_count is zero, this is not a
1456 specialization but rather a template instantiation, so there
1457 is no check we can perform here. */
1458 if (header_count && header_count != template_count + 1)
1461 /* Check that the number of template arguments at the
1462 innermost level for DECL is the same as for FN. */
1463 if (current_binding_level->kind == sk_template_parms
1464 && !current_binding_level->explicit_spec_p
1465 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1466 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1467 (current_template_parms))))
1470 /* DECL might be a specialization of FN. */
1471 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1472 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1474 /* For a non-static member function, we need to make sure
1475 that the const qualification is the same. Since
1476 get_bindings does not try to merge the "this" parameter,
1477 we must do the comparison explicitly. */
1478 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1479 && !same_type_p (TREE_VALUE (fn_arg_types),
1480 TREE_VALUE (decl_arg_types)))
1483 /* Skip the "this" parameter and, for constructors of
1484 classes with virtual bases, the VTT parameter. A
1485 full specialization of a constructor will have a VTT
1486 parameter, but a template never will. */
1488 = skip_artificial_parms_for (decl, decl_arg_types);
1490 = skip_artificial_parms_for (fn, fn_arg_types);
1492 /* Check that the number of function parameters matches.
1494 template <class T> void f(int i = 0);
1495 template <> void f<int>();
1496 The specialization f<int> is invalid but is not caught
1497 by get_bindings below. */
1498 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1501 /* Function templates cannot be specializations; there are
1502 no partial specializations of functions. Therefore, if
1503 the type of DECL does not match FN, there is no
1505 if (tsk == tsk_template)
1507 if (compparms (fn_arg_types, decl_arg_types))
1508 candidates = tree_cons (NULL_TREE, fn, candidates);
1512 /* See whether this function might be a specialization of this
1514 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1517 /* We cannot deduce template arguments that when used to
1518 specialize TMPL will produce DECL. */
1521 /* Save this template, and the arguments deduced. */
1522 templates = tree_cons (targs, fn, templates);
1524 else if (need_member_template)
1525 /* FN is an ordinary member function, and we need a
1526 specialization of a member template. */
1528 else if (TREE_CODE (fn) != FUNCTION_DECL)
1529 /* We can get IDENTIFIER_NODEs here in certain erroneous
1532 else if (!DECL_FUNCTION_MEMBER_P (fn))
1533 /* This is just an ordinary non-member function. Nothing can
1534 be a specialization of that. */
1536 else if (DECL_ARTIFICIAL (fn))
1537 /* Cannot specialize functions that are created implicitly. */
1541 tree decl_arg_types;
1543 /* This is an ordinary member function. However, since
1544 we're here, we can assume it's enclosing class is a
1545 template class. For example,
1547 template <typename T> struct S { void f(); };
1548 template <> void S<int>::f() {}
1550 Here, S<int>::f is a non-template, but S<int> is a
1551 template class. If FN has the same type as DECL, we
1552 might be in business. */
1554 if (!DECL_TEMPLATE_INFO (fn))
1555 /* Its enclosing class is an explicit specialization
1556 of a template class. This is not a candidate. */
1559 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1560 TREE_TYPE (TREE_TYPE (fn))))
1561 /* The return types differ. */
1564 /* Adjust the type of DECL in case FN is a static member. */
1565 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1566 if (DECL_STATIC_FUNCTION_P (fn)
1567 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1568 decl_arg_types = TREE_CHAIN (decl_arg_types);
1570 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1573 candidates = tree_cons (NULL_TREE, fn, candidates);
1577 if (templates && TREE_CHAIN (templates))
1583 It is possible for a specialization with a given function
1584 signature to be instantiated from more than one function
1585 template. In such cases, explicit specification of the
1586 template arguments must be used to uniquely identify the
1587 function template specialization being specialized.
1589 Note that here, there's no suggestion that we're supposed to
1590 determine which of the candidate templates is most
1591 specialized. However, we, also have:
1595 Partial ordering of overloaded function template
1596 declarations is used in the following contexts to select
1597 the function template to which a function template
1598 specialization refers:
1600 -- when an explicit specialization refers to a function
1603 So, we do use the partial ordering rules, at least for now.
1604 This extension can only serve to make invalid programs valid,
1605 so it's safe. And, there is strong anecdotal evidence that
1606 the committee intended the partial ordering rules to apply;
1607 the EDG front-end has that behavior, and John Spicer claims
1608 that the committee simply forgot to delete the wording in
1609 [temp.expl.spec]. */
1610 tree tmpl = most_specialized_instantiation (templates);
1611 if (tmpl != error_mark_node)
1614 TREE_CHAIN (templates) = NULL_TREE;
1618 if (templates == NULL_TREE && candidates == NULL_TREE)
1620 error ("template-id %qD for %q+D does not match any template "
1621 "declaration", template_id, decl);
1622 return error_mark_node;
1624 else if ((templates && TREE_CHAIN (templates))
1625 || (candidates && TREE_CHAIN (candidates))
1626 || (templates && candidates))
1628 error ("ambiguous template specialization %qD for %q+D",
1630 chainon (candidates, templates);
1631 print_candidates (candidates);
1632 return error_mark_node;
1635 /* We have one, and exactly one, match. */
1638 tree fn = TREE_VALUE (candidates);
1639 /* DECL is a re-declaration of a template function. */
1640 if (TREE_CODE (fn) == TEMPLATE_DECL)
1642 /* It was a specialization of an ordinary member function in a
1644 *targs_out = copy_node (DECL_TI_ARGS (fn));
1645 return DECL_TI_TEMPLATE (fn);
1648 /* It was a specialization of a template. */
1649 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1650 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1652 *targs_out = copy_node (targs);
1653 SET_TMPL_ARGS_LEVEL (*targs_out,
1654 TMPL_ARGS_DEPTH (*targs_out),
1655 TREE_PURPOSE (templates));
1658 *targs_out = TREE_PURPOSE (templates);
1659 return TREE_VALUE (templates);
1662 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1663 but with the default argument values filled in from those in the
1667 copy_default_args_to_explicit_spec_1 (tree spec_types,
1670 tree new_spec_types;
1675 if (spec_types == void_list_node)
1676 return void_list_node;
1678 /* Substitute into the rest of the list. */
1680 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1681 TREE_CHAIN (tmpl_types));
1683 /* Add the default argument for this parameter. */
1684 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1685 TREE_VALUE (spec_types),
1689 /* DECL is an explicit specialization. Replicate default arguments
1690 from the template it specializes. (That way, code like:
1692 template <class T> void f(T = 3);
1693 template <> void f(double);
1696 works, as required.) An alternative approach would be to look up
1697 the correct default arguments at the call-site, but this approach
1698 is consistent with how implicit instantiations are handled. */
1701 copy_default_args_to_explicit_spec (tree decl)
1706 tree new_spec_types;
1710 tree object_type = NULL_TREE;
1711 tree in_charge = NULL_TREE;
1712 tree vtt = NULL_TREE;
1714 /* See if there's anything we need to do. */
1715 tmpl = DECL_TI_TEMPLATE (decl);
1716 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1717 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1718 if (TREE_PURPOSE (t))
1723 old_type = TREE_TYPE (decl);
1724 spec_types = TYPE_ARG_TYPES (old_type);
1726 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1728 /* Remove the this pointer, but remember the object's type for
1730 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1731 spec_types = TREE_CHAIN (spec_types);
1732 tmpl_types = TREE_CHAIN (tmpl_types);
1734 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1736 /* DECL may contain more parameters than TMPL due to the extra
1737 in-charge parameter in constructors and destructors. */
1738 in_charge = spec_types;
1739 spec_types = TREE_CHAIN (spec_types);
1741 if (DECL_HAS_VTT_PARM_P (decl))
1744 spec_types = TREE_CHAIN (spec_types);
1748 /* Compute the merged default arguments. */
1750 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1752 /* Compute the new FUNCTION_TYPE. */
1756 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1761 /* Put the in-charge parameter back. */
1762 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1763 TREE_VALUE (in_charge),
1766 new_type = build_method_type_directly (object_type,
1767 TREE_TYPE (old_type),
1771 new_type = build_function_type (TREE_TYPE (old_type),
1773 new_type = cp_build_type_attribute_variant (new_type,
1774 TYPE_ATTRIBUTES (old_type));
1775 new_type = build_exception_variant (new_type,
1776 TYPE_RAISES_EXCEPTIONS (old_type));
1777 TREE_TYPE (decl) = new_type;
1780 /* Check to see if the function just declared, as indicated in
1781 DECLARATOR, and in DECL, is a specialization of a function
1782 template. We may also discover that the declaration is an explicit
1783 instantiation at this point.
1785 Returns DECL, or an equivalent declaration that should be used
1786 instead if all goes well. Issues an error message if something is
1787 amiss. Returns error_mark_node if the error is not easily
1790 FLAGS is a bitmask consisting of the following flags:
1792 2: The function has a definition.
1793 4: The function is a friend.
1795 The TEMPLATE_COUNT is the number of references to qualifying
1796 template classes that appeared in the name of the function. For
1799 template <class T> struct S { void f(); };
1802 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1803 classes are not counted in the TEMPLATE_COUNT, so that in
1805 template <class T> struct S {};
1806 template <> struct S<int> { void f(); }
1807 template <> void S<int>::f();
1809 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1810 invalid; there should be no template <>.)
1812 If the function is a specialization, it is marked as such via
1813 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1814 is set up correctly, and it is added to the list of specializations
1815 for that template. */
1818 check_explicit_specialization (tree declarator,
1823 int have_def = flags & 2;
1824 int is_friend = flags & 4;
1825 int specialization = 0;
1826 int explicit_instantiation = 0;
1827 int member_specialization = 0;
1828 tree ctype = DECL_CLASS_CONTEXT (decl);
1829 tree dname = DECL_NAME (decl);
1834 if (!processing_specialization)
1837 tsk = tsk_excessive_parms;
1840 tsk = current_tmpl_spec_kind (template_count);
1845 if (processing_specialization)
1848 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1850 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1853 /* This could be something like:
1855 template <class T> void f(T);
1856 class S { friend void f<>(int); } */
1860 /* This case handles bogus declarations like template <>
1861 template <class T> void f<int>(); */
1863 error ("template-id %qD in declaration of primary template",
1870 case tsk_invalid_member_spec:
1871 /* The error has already been reported in
1872 check_specialization_scope. */
1873 return error_mark_node;
1875 case tsk_invalid_expl_inst:
1876 error ("template parameter list used in explicit instantiation");
1882 error ("definition provided for explicit instantiation");
1884 explicit_instantiation = 1;
1887 case tsk_excessive_parms:
1888 case tsk_insufficient_parms:
1889 if (tsk == tsk_excessive_parms)
1890 error ("too many template parameter lists in declaration of %qD",
1892 else if (template_header_count)
1893 error("too few template parameter lists in declaration of %qD", decl);
1895 error("explicit specialization of %qD must be introduced by "
1896 "%<template <>%>", decl);
1900 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1902 member_specialization = 1;
1908 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1910 /* This case handles bogus declarations like template <>
1911 template <class T> void f<int>(); */
1913 if (uses_template_parms (declarator))
1914 error ("function template partial specialization %qD "
1915 "is not allowed", declarator);
1917 error ("template-id %qD in declaration of primary template",
1922 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1923 /* This is a specialization of a member template, without
1924 specialization the containing class. Something like:
1926 template <class T> struct S {
1927 template <class U> void f (U);
1929 template <> template <class U> void S<int>::f(U) {}
1931 That's a specialization -- but of the entire template. */
1939 if (specialization || member_specialization)
1941 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1942 for (; t; t = TREE_CHAIN (t))
1943 if (TREE_PURPOSE (t))
1946 ("default argument specified in explicit specialization");
1951 if (specialization || member_specialization || explicit_instantiation)
1953 tree tmpl = NULL_TREE;
1954 tree targs = NULL_TREE;
1956 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1957 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1961 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
1966 /* If there is no class context, the explicit instantiation
1967 must be at namespace scope. */
1968 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
1970 /* Find the namespace binding, using the declaration
1972 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
1974 if (fns == error_mark_node || !is_overloaded_fn (fns))
1976 error ("%qD is not a template function", dname);
1977 fns = error_mark_node;
1981 tree fn = OVL_CURRENT (fns);
1982 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
1983 CP_DECL_CONTEXT (fn)))
1984 error ("%qD is not declared in %qD",
1985 decl, current_namespace);
1989 declarator = lookup_template_function (fns, NULL_TREE);
1992 if (declarator == error_mark_node)
1993 return error_mark_node;
1995 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1997 if (!explicit_instantiation)
1998 /* A specialization in class scope. This is invalid,
1999 but the error will already have been flagged by
2000 check_specialization_scope. */
2001 return error_mark_node;
2004 /* It's not valid to write an explicit instantiation in
2007 class C { template void f(); }
2009 This case is caught by the parser. However, on
2012 template class C { void f(); };
2014 (which is invalid) we can get here. The error will be
2021 else if (ctype != NULL_TREE
2022 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2025 /* Find the list of functions in ctype that have the same
2026 name as the declared function. */
2027 tree name = TREE_OPERAND (declarator, 0);
2028 tree fns = NULL_TREE;
2031 if (constructor_name_p (name, ctype))
2033 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2035 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
2036 : !CLASSTYPE_DESTRUCTORS (ctype))
2038 /* From [temp.expl.spec]:
2040 If such an explicit specialization for the member
2041 of a class template names an implicitly-declared
2042 special member function (clause _special_), the
2043 program is ill-formed.
2045 Similar language is found in [temp.explicit]. */
2046 error ("specialization of implicitly-declared special member function");
2047 return error_mark_node;
2050 name = is_constructor ? ctor_identifier : dtor_identifier;
2053 if (!DECL_CONV_FN_P (decl))
2055 idx = lookup_fnfields_1 (ctype, name);
2057 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2061 VEC(tree,gc) *methods;
2064 /* For a type-conversion operator, we cannot do a
2065 name-based lookup. We might be looking for `operator
2066 int' which will be a specialization of `operator T'.
2067 So, we find *all* the conversion operators, and then
2068 select from them. */
2071 methods = CLASSTYPE_METHOD_VEC (ctype);
2073 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2074 VEC_iterate (tree, methods, idx, ovl);
2077 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2078 /* There are no more conversion functions. */
2081 /* Glue all these conversion functions together
2082 with those we already have. */
2083 for (; ovl; ovl = OVL_NEXT (ovl))
2084 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2088 if (fns == NULL_TREE)
2090 error ("no member function %qD declared in %qT", name, ctype);
2091 return error_mark_node;
2094 TREE_OPERAND (declarator, 0) = fns;
2097 /* Figure out what exactly is being specialized at this point.
2098 Note that for an explicit instantiation, even one for a
2099 member function, we cannot tell apriori whether the
2100 instantiation is for a member template, or just a member
2101 function of a template class. Even if a member template is
2102 being instantiated, the member template arguments may be
2103 elided if they can be deduced from the rest of the
2105 tmpl = determine_specialization (declarator, decl,
2107 member_specialization,
2111 if (!tmpl || tmpl == error_mark_node)
2112 /* We couldn't figure out what this declaration was
2114 return error_mark_node;
2117 tree gen_tmpl = most_general_template (tmpl);
2119 if (explicit_instantiation)
2121 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2122 is done by do_decl_instantiation later. */
2124 int arg_depth = TMPL_ARGS_DEPTH (targs);
2125 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2127 if (arg_depth > parm_depth)
2129 /* If TMPL is not the most general template (for
2130 example, if TMPL is a friend template that is
2131 injected into namespace scope), then there will
2132 be too many levels of TARGS. Remove some of them
2137 new_targs = make_tree_vec (parm_depth);
2138 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2139 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2140 = TREE_VEC_ELT (targs, i);
2144 return instantiate_template (tmpl, targs, tf_error);
2147 /* If we thought that the DECL was a member function, but it
2148 turns out to be specializing a static member function,
2149 make DECL a static member function as well. */
2150 if (DECL_STATIC_FUNCTION_P (tmpl)
2151 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2152 revert_static_member_fn (decl);
2154 /* If this is a specialization of a member template of a
2155 template class, we want to return the TEMPLATE_DECL, not
2156 the specialization of it. */
2157 if (tsk == tsk_template)
2159 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2160 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2163 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2164 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2165 = DECL_SOURCE_LOCATION (decl);
2166 /* We want to use the argument list specified in the
2167 definition, not in the original declaration. */
2168 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2169 = DECL_ARGUMENTS (decl);
2174 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2175 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2177 /* Inherit default function arguments from the template
2178 DECL is specializing. */
2179 copy_default_args_to_explicit_spec (decl);
2181 /* This specialization has the same protection as the
2182 template it specializes. */
2183 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2184 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2186 /* If DECL is a friend declaration, declared using an
2187 unqualified name, the namespace associated with DECL may
2188 have been set incorrectly. For example, in:
2190 template <typename T> void f(T);
2192 struct S { friend void f<int>(int); }
2195 we will have set the DECL_CONTEXT for the friend
2196 declaration to N, rather than to the global namespace. */
2197 if (DECL_NAMESPACE_SCOPE_P (decl))
2198 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2200 if (is_friend && !have_def)
2201 /* This is not really a declaration of a specialization.
2202 It's just the name of an instantiation. But, it's not
2203 a request for an instantiation, either. */
2204 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2205 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2206 /* This is indeed a specialization. In case of constructors
2207 and destructors, we need in-charge and not-in-charge
2208 versions in V3 ABI. */
2209 clone_function_decl (decl, /*update_method_vec_p=*/0);
2211 /* Register this specialization so that we can find it
2213 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2220 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2221 parameters. These are represented in the same format used for
2222 DECL_TEMPLATE_PARMS. */
2225 comp_template_parms (tree parms1, tree parms2)
2230 if (parms1 == parms2)
2233 for (p1 = parms1, p2 = parms2;
2234 p1 != NULL_TREE && p2 != NULL_TREE;
2235 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2237 tree t1 = TREE_VALUE (p1);
2238 tree t2 = TREE_VALUE (p2);
2241 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2242 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2244 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2247 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2249 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2250 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2252 /* If either of the template parameters are invalid, assume
2253 they match for the sake of error recovery. */
2254 if (parm1 == error_mark_node || parm2 == error_mark_node)
2257 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2260 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2262 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2267 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2268 /* One set of parameters has more parameters lists than the
2275 /* Complain if DECL shadows a template parameter.
2277 [temp.local]: A template-parameter shall not be redeclared within its
2278 scope (including nested scopes). */
2281 check_template_shadow (tree decl)
2285 /* If we're not in a template, we can't possibly shadow a template
2287 if (!current_template_parms)
2290 /* Figure out what we're shadowing. */
2291 if (TREE_CODE (decl) == OVERLOAD)
2292 decl = OVL_CURRENT (decl);
2293 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2295 /* If there's no previous binding for this name, we're not shadowing
2296 anything, let alone a template parameter. */
2300 /* If we're not shadowing a template parameter, we're done. Note
2301 that OLDDECL might be an OVERLOAD (or perhaps even an
2302 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2304 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2307 /* We check for decl != olddecl to avoid bogus errors for using a
2308 name inside a class. We check TPFI to avoid duplicate errors for
2309 inline member templates. */
2311 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2314 error ("declaration of %q+#D", decl);
2315 error (" shadows template parm %q+#D", olddecl);
2318 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2319 ORIG_LEVEL, DECL, and TYPE. */
2322 build_template_parm_index (int index,
2328 tree t = make_node (TEMPLATE_PARM_INDEX);
2329 TEMPLATE_PARM_IDX (t) = index;
2330 TEMPLATE_PARM_LEVEL (t) = level;
2331 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2332 TEMPLATE_PARM_DECL (t) = decl;
2333 TREE_TYPE (t) = type;
2334 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2335 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2336 TREE_READONLY (t) = TREE_READONLY (decl);
2341 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2342 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2343 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2344 new one is created. */
2347 reduce_template_parm_level (tree index, tree type, int levels)
2349 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2350 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2351 != TEMPLATE_PARM_LEVEL (index) - levels))
2353 tree orig_decl = TEMPLATE_PARM_DECL (index);
2356 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2357 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2358 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2359 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2360 DECL_ARTIFICIAL (decl) = 1;
2361 SET_DECL_TEMPLATE_PARM_P (decl);
2363 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2364 TEMPLATE_PARM_LEVEL (index) - levels,
2365 TEMPLATE_PARM_ORIG_LEVEL (index),
2367 TEMPLATE_PARM_DESCENDANTS (index) = t;
2369 /* Template template parameters need this. */
2370 if (TREE_CODE (decl) != CONST_DECL)
2371 DECL_TEMPLATE_PARMS (decl)
2372 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2375 return TEMPLATE_PARM_DESCENDANTS (index);
2378 /* Process information from new template parameter PARM and append it to the
2379 LIST being built. This new parameter is a non-type parameter iff
2380 IS_NON_TYPE is true. */
2383 process_template_parm (tree list, tree parm, bool is_non_type)
2390 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2391 defval = TREE_PURPOSE (parm);
2395 tree p = tree_last (list);
2397 if (p && TREE_VALUE (p) != error_mark_node)
2400 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2401 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2403 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2413 parm = TREE_VALUE (parm);
2415 SET_DECL_TEMPLATE_PARM_P (parm);
2417 if (TREE_TYPE (parm) == error_mark_node)
2419 err_parm_list = build_tree_list (defval, parm);
2420 TREE_VALUE (err_parm_list) = error_mark_node;
2421 return chainon (list, err_parm_list);
2427 The top-level cv-qualifiers on the template-parameter are
2428 ignored when determining its type. */
2429 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2430 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2432 err_parm_list = build_tree_list (defval, parm);
2433 TREE_VALUE (err_parm_list) = error_mark_node;
2434 return chainon (list, err_parm_list);
2438 /* A template parameter is not modifiable. */
2439 TREE_CONSTANT (parm) = 1;
2440 TREE_INVARIANT (parm) = 1;
2441 TREE_READONLY (parm) = 1;
2442 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2443 TREE_CONSTANT (decl) = 1;
2444 TREE_INVARIANT (decl) = 1;
2445 TREE_READONLY (decl) = 1;
2446 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2447 = build_template_parm_index (idx, processing_template_decl,
2448 processing_template_decl,
2449 decl, TREE_TYPE (parm));
2454 parm = TREE_VALUE (TREE_VALUE (parm));
2456 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2458 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2459 /* This is for distinguishing between real templates and template
2460 template parameters */
2461 TREE_TYPE (parm) = t;
2462 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2467 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2468 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2469 decl = build_decl (TYPE_DECL, parm, t);
2472 TYPE_NAME (t) = decl;
2473 TYPE_STUB_DECL (t) = decl;
2475 TEMPLATE_TYPE_PARM_INDEX (t)
2476 = build_template_parm_index (idx, processing_template_decl,
2477 processing_template_decl,
2478 decl, TREE_TYPE (parm));
2480 DECL_ARTIFICIAL (decl) = 1;
2481 SET_DECL_TEMPLATE_PARM_P (decl);
2483 parm = build_tree_list (defval, parm);
2484 return chainon (list, parm);
2487 /* The end of a template parameter list has been reached. Process the
2488 tree list into a parameter vector, converting each parameter into a more
2489 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2493 end_template_parm_list (tree parms)
2497 tree saved_parmlist = make_tree_vec (list_length (parms));
2499 current_template_parms
2500 = tree_cons (size_int (processing_template_decl),
2501 saved_parmlist, current_template_parms);
2503 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2505 next = TREE_CHAIN (parm);
2506 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2507 TREE_CHAIN (parm) = NULL_TREE;
2510 --processing_template_parmlist;
2512 return saved_parmlist;
2515 /* end_template_decl is called after a template declaration is seen. */
2518 end_template_decl (void)
2520 reset_specialization ();
2522 if (! processing_template_decl)
2525 /* This matches the pushlevel in begin_template_parm_list. */
2528 --processing_template_decl;
2529 current_template_parms = TREE_CHAIN (current_template_parms);
2532 /* Given a template argument vector containing the template PARMS.
2533 The innermost PARMS are given first. */
2536 current_template_args (void)
2539 tree args = NULL_TREE;
2540 int length = TMPL_PARMS_DEPTH (current_template_parms);
2543 /* If there is only one level of template parameters, we do not
2544 create a TREE_VEC of TREE_VECs. Instead, we return a single
2545 TREE_VEC containing the arguments. */
2547 args = make_tree_vec (length);
2549 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2551 tree a = copy_node (TREE_VALUE (header));
2554 TREE_TYPE (a) = NULL_TREE;
2555 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2557 tree t = TREE_VEC_ELT (a, i);
2559 /* T will be a list if we are called from within a
2560 begin/end_template_parm_list pair, but a vector directly
2561 if within a begin/end_member_template_processing pair. */
2562 if (TREE_CODE (t) == TREE_LIST)
2566 if (t != error_mark_node)
2568 if (TREE_CODE (t) == TYPE_DECL
2569 || TREE_CODE (t) == TEMPLATE_DECL)
2572 t = DECL_INITIAL (t);
2575 TREE_VEC_ELT (a, i) = t;
2580 TREE_VEC_ELT (args, --l) = a;
2588 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2589 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
2590 a member template. Used by push_template_decl below. */
2593 build_template_decl (tree decl, tree parms, bool member_template_p)
2595 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2596 DECL_TEMPLATE_PARMS (tmpl) = parms;
2597 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2598 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
2599 if (DECL_LANG_SPECIFIC (decl))
2601 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2602 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2603 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2604 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2605 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2606 if (DECL_OVERLOADED_OPERATOR_P (decl))
2607 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2608 DECL_OVERLOADED_OPERATOR_P (decl));
2614 struct template_parm_data
2616 /* The level of the template parameters we are currently
2620 /* The index of the specialization argument we are currently
2624 /* An array whose size is the number of template parameters. The
2625 elements are nonzero if the parameter has been used in any one
2626 of the arguments processed so far. */
2629 /* An array whose size is the number of template arguments. The
2630 elements are nonzero if the argument makes use of template
2631 parameters of this level. */
2632 int* arg_uses_template_parms;
2635 /* Subroutine of push_template_decl used to see if each template
2636 parameter in a partial specialization is used in the explicit
2637 argument list. If T is of the LEVEL given in DATA (which is
2638 treated as a template_parm_data*), then DATA->PARMS is marked
2642 mark_template_parm (tree t, void* data)
2646 struct template_parm_data* tpd = (struct template_parm_data*) data;
2648 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2650 level = TEMPLATE_PARM_LEVEL (t);
2651 idx = TEMPLATE_PARM_IDX (t);
2655 level = TEMPLATE_TYPE_LEVEL (t);
2656 idx = TEMPLATE_TYPE_IDX (t);
2659 if (level == tpd->level)
2661 tpd->parms[idx] = 1;
2662 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2665 /* Return zero so that for_each_template_parm will continue the
2666 traversal of the tree; we want to mark *every* template parm. */
2670 /* Process the partial specialization DECL. */
2673 process_partial_specialization (tree decl)
2675 tree type = TREE_TYPE (decl);
2676 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2677 tree specargs = CLASSTYPE_TI_ARGS (type);
2678 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2679 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2680 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2681 int nargs = TREE_VEC_LENGTH (inner_args);
2682 int ntparms = TREE_VEC_LENGTH (inner_parms);
2684 int did_error_intro = 0;
2685 struct template_parm_data tpd;
2686 struct template_parm_data tpd2;
2688 /* We check that each of the template parameters given in the
2689 partial specialization is used in the argument list to the
2690 specialization. For example:
2692 template <class T> struct S;
2693 template <class T> struct S<T*>;
2695 The second declaration is OK because `T*' uses the template
2696 parameter T, whereas
2698 template <class T> struct S<int>;
2700 is no good. Even trickier is:
2711 The S2<T> declaration is actually invalid; it is a
2712 full-specialization. Of course,
2715 struct S2<T (*)(U)>;
2717 or some such would have been OK. */
2718 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2719 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
2720 memset (tpd.parms, 0, sizeof (int) * ntparms);
2722 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
2723 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2724 for (i = 0; i < nargs; ++i)
2726 tpd.current_arg = i;
2727 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2728 &mark_template_parm,
2732 for (i = 0; i < ntparms; ++i)
2733 if (tpd.parms[i] == 0)
2735 /* One of the template parms was not used in the
2737 if (!did_error_intro)
2739 error ("template parameters not used in partial specialization:");
2740 did_error_intro = 1;
2743 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2746 /* [temp.class.spec]
2748 The argument list of the specialization shall not be identical to
2749 the implicit argument list of the primary template. */
2750 if (comp_template_args
2752 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2754 error ("partial specialization %qT does not specialize any template arguments", type);
2756 /* [temp.class.spec]
2758 A partially specialized non-type argument expression shall not
2759 involve template parameters of the partial specialization except
2760 when the argument expression is a simple identifier.
2762 The type of a template parameter corresponding to a specialized
2763 non-type argument shall not be dependent on a parameter of the
2765 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
2767 for (i = 0; i < nargs; ++i)
2769 tree arg = TREE_VEC_ELT (inner_args, i);
2770 if (/* These first two lines are the `non-type' bit. */
2772 && TREE_CODE (arg) != TEMPLATE_DECL
2773 /* This next line is the `argument expression is not just a
2774 simple identifier' condition and also the `specialized
2775 non-type argument' bit. */
2776 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2778 if (tpd.arg_uses_template_parms[i])
2779 error ("template argument %qE involves template parameter(s)", arg);
2782 /* Look at the corresponding template parameter,
2783 marking which template parameters its type depends
2786 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2791 /* We haven't yet initialized TPD2. Do so now. */
2792 tpd2.arg_uses_template_parms
2793 = (int *) alloca (sizeof (int) * nargs);
2794 /* The number of parameters here is the number in the
2795 main template, which, as checked in the assertion
2797 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
2799 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2802 /* Mark the template parameters. But this time, we're
2803 looking for the template parameters of the main
2804 template, not in the specialization. */
2805 tpd2.current_arg = i;
2806 tpd2.arg_uses_template_parms[i] = 0;
2807 memset (tpd2.parms, 0, sizeof (int) * nargs);
2808 for_each_template_parm (type,
2809 &mark_template_parm,
2813 if (tpd2.arg_uses_template_parms [i])
2815 /* The type depended on some template parameters.
2816 If they are fully specialized in the
2817 specialization, that's OK. */
2819 for (j = 0; j < nargs; ++j)
2820 if (tpd2.parms[j] != 0
2821 && tpd.arg_uses_template_parms [j])
2823 error ("type %qT of template argument %qE depends "
2824 "on template parameter(s)",
2834 if (retrieve_specialization (maintmpl, specargs,
2835 /*class_specializations_p=*/true))
2836 /* We've already got this specialization. */
2839 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2840 = tree_cons (specargs, inner_parms,
2841 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2842 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2846 /* Check that a template declaration's use of default arguments is not
2847 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2848 nonzero if DECL is the thing declared by a primary template.
2849 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2852 check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2855 int last_level_to_check;
2860 A default template-argument shall not be specified in a
2861 function template declaration or a function template definition, nor
2862 in the template-parameter-list of the definition of a member of a
2865 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2866 /* You can't have a function template declaration in a local
2867 scope, nor you can you define a member of a class template in a
2871 if (current_class_type
2872 && !TYPE_BEING_DEFINED (current_class_type)
2873 && DECL_LANG_SPECIFIC (decl)
2874 /* If this is either a friend defined in the scope of the class
2875 or a member function. */
2876 && (DECL_FUNCTION_MEMBER_P (decl)
2877 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2878 : DECL_FRIEND_CONTEXT (decl)
2879 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2881 /* And, if it was a member function, it really was defined in
2882 the scope of the class. */
2883 && (!DECL_FUNCTION_MEMBER_P (decl)
2884 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2885 /* We already checked these parameters when the template was
2886 declared, so there's no need to do it again now. This function
2887 was defined in class scope, but we're processing it's body now
2888 that the class is complete. */
2893 If a template-parameter has a default template-argument, all
2894 subsequent template-parameters shall have a default
2895 template-argument supplied. */
2896 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2898 tree inner_parms = TREE_VALUE (parm_level);
2899 int ntparms = TREE_VEC_LENGTH (inner_parms);
2900 int seen_def_arg_p = 0;
2903 for (i = 0; i < ntparms; ++i)
2905 tree parm = TREE_VEC_ELT (inner_parms, i);
2907 if (parm == error_mark_node)
2910 if (TREE_PURPOSE (parm))
2912 else if (seen_def_arg_p)
2914 error ("no default argument for %qD", TREE_VALUE (parm));
2915 /* For better subsequent error-recovery, we indicate that
2916 there should have been a default argument. */
2917 TREE_PURPOSE (parm) = error_mark_node;
2922 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2923 /* For an ordinary class template, default template arguments are
2924 allowed at the innermost level, e.g.:
2925 template <class T = int>
2927 but, in a partial specialization, they're not allowed even
2928 there, as we have in [temp.class.spec]:
2930 The template parameter list of a specialization shall not
2931 contain default template argument values.
2933 So, for a partial specialization, or for a function template,
2934 we look at all of them. */
2937 /* But, for a primary class template that is not a partial
2938 specialization we look at all template parameters except the
2940 parms = TREE_CHAIN (parms);
2942 /* Figure out what error message to issue. */
2943 if (TREE_CODE (decl) == FUNCTION_DECL)
2944 msg = "default template arguments may not be used in function templates";
2945 else if (is_partial)
2946 msg = "default template arguments may not be used in partial specializations";
2948 msg = "default argument for template parameter for class enclosing %qD";
2950 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2951 /* If we're inside a class definition, there's no need to
2952 examine the parameters to the class itself. On the one
2953 hand, they will be checked when the class is defined, and,
2954 on the other, default arguments are valid in things like:
2955 template <class T = double>
2956 struct S { template <class U> void f(U); };
2957 Here the default argument for `S' has no bearing on the
2958 declaration of `f'. */
2959 last_level_to_check = template_class_depth (current_class_type) + 1;
2961 /* Check everything. */
2962 last_level_to_check = 0;
2964 for (parm_level = parms;
2965 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2966 parm_level = TREE_CHAIN (parm_level))
2968 tree inner_parms = TREE_VALUE (parm_level);
2972 ntparms = TREE_VEC_LENGTH (inner_parms);
2973 for (i = 0; i < ntparms; ++i)
2975 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
2978 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2986 /* Clear out the default argument so that we are not
2988 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2992 /* At this point, if we're still interested in issuing messages,
2993 they must apply to classes surrounding the object declared. */
2995 msg = "default argument for template parameter for class enclosing %qD";
2999 /* Worker for push_template_decl_real, called via
3000 for_each_template_parm. DATA is really an int, indicating the
3001 level of the parameters we are interested in. If T is a template
3002 parameter of that level, return nonzero. */
3005 template_parm_this_level_p (tree t, void* data)
3007 int this_level = *(int *)data;
3010 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3011 level = TEMPLATE_PARM_LEVEL (t);
3013 level = TEMPLATE_TYPE_LEVEL (t);
3014 return level == this_level;
3017 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3018 parameters given by current_template_args, or reuses a
3019 previously existing one, if appropriate. Returns the DECL, or an
3020 equivalent one, if it is replaced via a call to duplicate_decls.
3022 If IS_FRIEND is true, DECL is a friend declaration. */
3025 push_template_decl_real (tree decl, bool is_friend)
3033 int new_template_p = 0;
3034 /* True if the template is a member template, in the sense of
3036 bool member_template_p = false;
3038 if (decl == error_mark_node)
3041 /* See if this is a partial specialization. */
3042 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3043 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3044 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3046 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3050 /* For a friend, we want the context of the friend function, not
3051 the type of which it is a friend. */
3052 ctx = DECL_CONTEXT (decl);
3053 else if (CP_DECL_CONTEXT (decl)
3054 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3055 /* In the case of a virtual function, we want the class in which
3057 ctx = CP_DECL_CONTEXT (decl);
3059 /* Otherwise, if we're currently defining some class, the DECL
3060 is assumed to be a member of the class. */
3061 ctx = current_scope ();
3063 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3066 if (!DECL_CONTEXT (decl))
3067 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3069 /* See if this is a primary template. */
3070 if (is_friend && ctx)
3071 /* A friend template that specifies a class context, i.e.
3072 template <typename T> friend void A<T>::f();
3076 primary = template_parm_scope_p ();
3080 if (DECL_CLASS_SCOPE_P (decl))
3081 member_template_p = true;
3082 if (TREE_CODE (decl) == TYPE_DECL
3083 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3084 error ("template class without a name");
3085 else if (TREE_CODE (decl) == FUNCTION_DECL)
3087 if (DECL_DESTRUCTOR_P (decl))
3091 A destructor shall not be a member template. */
3092 error ("destructor %qD declared as member template", decl);
3093 return error_mark_node;
3095 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3096 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3097 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3098 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3099 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3100 == void_list_node)))
3102 /* [basic.stc.dynamic.allocation]
3104 An allocation function can be a function
3105 template. ... Template allocation functions shall
3106 have two or more parameters. */
3107 error ("invalid template declaration of %qD", decl);
3108 return error_mark_node;
3111 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3112 && CLASS_TYPE_P (TREE_TYPE (decl)))
3116 error ("template declaration of %q#D", decl);
3117 return error_mark_node;
3121 /* Check to see that the rules regarding the use of default
3122 arguments are not being violated. */
3123 check_default_tmpl_args (decl, current_template_parms,
3124 primary, is_partial);
3127 return process_partial_specialization (decl);
3129 args = current_template_args ();
3132 || TREE_CODE (ctx) == FUNCTION_DECL
3133 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3134 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3136 if (DECL_LANG_SPECIFIC (decl)
3137 && DECL_TEMPLATE_INFO (decl)
3138 && DECL_TI_TEMPLATE (decl))
3139 tmpl = DECL_TI_TEMPLATE (decl);
3140 /* If DECL is a TYPE_DECL for a class-template, then there won't
3141 be DECL_LANG_SPECIFIC. The information equivalent to
3142 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3143 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3144 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3145 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3147 /* Since a template declaration already existed for this
3148 class-type, we must be redeclaring it here. Make sure
3149 that the redeclaration is valid. */
3150 redeclare_class_template (TREE_TYPE (decl),
3151 current_template_parms);
3152 /* We don't need to create a new TEMPLATE_DECL; just use the
3153 one we already had. */
3154 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3158 tmpl = build_template_decl (decl, current_template_parms,
3162 if (DECL_LANG_SPECIFIC (decl)
3163 && DECL_TEMPLATE_SPECIALIZATION (decl))
3165 /* A specialization of a member template of a template
3167 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3168 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3169 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3175 tree a, t, current, parms;
3178 if (TREE_CODE (decl) == TYPE_DECL)
3180 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
3181 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
3182 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3183 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3184 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3187 error ("%qD does not declare a template type", decl);
3191 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
3193 error ("template definition of non-template %q#D", decl);
3197 tmpl = DECL_TI_TEMPLATE (decl);
3199 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3200 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3201 && DECL_TEMPLATE_SPECIALIZATION (decl)
3202 && DECL_MEMBER_TEMPLATE_P (tmpl))
3206 /* The declaration is a specialization of a member
3207 template, declared outside the class. Therefore, the
3208 innermost template arguments will be NULL, so we
3209 replace them with the arguments determined by the
3210 earlier call to check_explicit_specialization. */
3211 args = DECL_TI_ARGS (decl);
3214 = build_template_decl (decl, current_template_parms,
3216 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3217 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3218 DECL_TI_TEMPLATE (decl) = new_tmpl;
3219 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3220 DECL_TEMPLATE_INFO (new_tmpl)
3221 = tree_cons (tmpl, args, NULL_TREE);
3223 register_specialization (new_tmpl,
3224 most_general_template (tmpl),
3230 /* Make sure the template headers we got make sense. */
3232 parms = DECL_TEMPLATE_PARMS (tmpl);
3233 i = TMPL_PARMS_DEPTH (parms);
3234 if (TMPL_ARGS_DEPTH (args) != i)
3236 error ("expected %d levels of template parms for %q#D, got %d",
3237 i, decl, TMPL_ARGS_DEPTH (args));
3240 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3242 a = TMPL_ARGS_LEVEL (args, i);
3243 t = INNERMOST_TEMPLATE_PARMS (parms);
3245 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3247 if (current == decl)
3248 error ("got %d template parameters for %q#D",
3249 TREE_VEC_LENGTH (a), decl);
3251 error ("got %d template parameters for %q#T",
3252 TREE_VEC_LENGTH (a), current);
3253 error (" but %d required", TREE_VEC_LENGTH (t));
3254 return error_mark_node;
3257 /* Perhaps we should also check that the parms are used in the
3258 appropriate qualifying scopes in the declarator? */
3260 if (current == decl)
3263 current = TYPE_CONTEXT (current);
3267 DECL_TEMPLATE_RESULT (tmpl) = decl;
3268 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3270 /* Push template declarations for global functions and types. Note
3271 that we do not try to push a global template friend declared in a
3272 template class; such a thing may well depend on the template
3273 parameters of the class. */
3274 if (new_template_p && !ctx
3275 && !(is_friend && template_class_depth (current_class_type) > 0))
3277 tmpl = pushdecl_namespace_level (tmpl, is_friend);
3278 if (tmpl == error_mark_node)
3279 return error_mark_node;
3281 /* Hide template friend classes that haven't been declared yet. */
3282 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
3284 DECL_ANTICIPATED (tmpl) = 1;
3285 DECL_FRIEND_P (tmpl) = 1;
3291 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3292 if (DECL_CONV_FN_P (tmpl))
3294 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3296 /* It is a conversion operator. See if the type converted to
3297 depends on innermost template operands. */
3299 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3301 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3305 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3306 back to its most general template. If TMPL is a specialization,
3307 ARGS may only have the innermost set of arguments. Add the missing
3308 argument levels if necessary. */
3309 if (DECL_TEMPLATE_INFO (tmpl))
3310 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3312 info = tree_cons (tmpl, args, NULL_TREE);
3314 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3316 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3317 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
3318 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3319 /* Don't change the name if we've already set it up. */
3320 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
3321 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
3323 else if (DECL_LANG_SPECIFIC (decl))
3324 DECL_TEMPLATE_INFO (decl) = info;
3326 return DECL_TEMPLATE_RESULT (tmpl);
3330 push_template_decl (tree decl)
3332 return push_template_decl_real (decl, false);
3335 /* Called when a class template TYPE is redeclared with the indicated
3336 template PARMS, e.g.:
3338 template <class T> struct S;
3339 template <class T> struct S {}; */
3342 redeclare_class_template (tree type, tree parms)
3348 if (!TYPE_TEMPLATE_INFO (type))
3350 error ("%qT is not a template type", type);
3354 tmpl = TYPE_TI_TEMPLATE (type);
3355 if (!PRIMARY_TEMPLATE_P (tmpl))
3356 /* The type is nested in some template class. Nothing to worry
3357 about here; there are no new template parameters for the nested
3363 error ("template specifiers not specified in declaration of %qD",
3368 parms = INNERMOST_TEMPLATE_PARMS (parms);
3369 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3371 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3373 error ("previous declaration %q+D", tmpl);
3374 error ("used %d template parameter(s) instead of %d",
3375 TREE_VEC_LENGTH (tmpl_parms),
3376 TREE_VEC_LENGTH (parms));
3380 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3387 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
3388 || TREE_VEC_ELT (parms, i) == error_mark_node)
3391 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3392 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3393 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3394 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3396 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
3398 if (tmpl_parm != error_mark_node
3399 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
3400 || (TREE_CODE (tmpl_parm) != TYPE_DECL
3401 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
3403 error ("template parameter %q+#D", tmpl_parm);
3404 error ("redeclared here as %q#D", parm);
3408 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3410 /* We have in [temp.param]:
3412 A template-parameter may not be given default arguments
3413 by two different declarations in the same scope. */
3414 error ("redefinition of default argument for %q#D", parm);
3415 error ("%J original definition appeared here", tmpl_parm);
3419 if (parm_default != NULL_TREE)
3420 /* Update the previous template parameters (which are the ones
3421 that will really count) with the new default value. */
3422 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3423 else if (tmpl_default != NULL_TREE)
3424 /* Update the new parameters, too; they'll be used as the
3425 parameters for any members. */
3426 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3432 /* Simplify EXPR if it is a non-dependent expression. Returns the
3433 (possibly simplified) expression. */
3436 fold_non_dependent_expr (tree expr)
3438 if (expr == NULL_TREE)
3441 /* If we're in a template, but EXPR isn't value dependent, simplify
3442 it. We're supposed to treat:
3444 template <typename T> void f(T[1 + 1]);
3445 template <typename T> void f(T[2]);
3447 as two declarations of the same function, for example. */
3448 if (processing_template_decl
3449 && !type_dependent_expression_p (expr)
3450 && !value_dependent_expression_p (expr))
3452 HOST_WIDE_INT saved_processing_template_decl;
3454 saved_processing_template_decl = processing_template_decl;
3455 processing_template_decl = 0;
3456 expr = tsubst_copy_and_build (expr,
3459 /*in_decl=*/NULL_TREE,
3460 /*function_p=*/false,
3461 /*integral_constant_expression_p=*/true);
3462 processing_template_decl = saved_processing_template_decl;
3467 /* EXPR is an expression which is used in a constant-expression context.
3468 For instance, it could be a VAR_DECL with a constant initializer.
3469 Extract the innest constant expression.
3471 This is basically a more powerful version of
3472 integral_constant_value, which can be used also in templates where
3473 initializers can maintain a syntactic rather than semantic form
3474 (even if they are non-dependent, for access-checking purposes). */
3477 fold_decl_constant_value (tree expr)
3479 tree const_expr = expr;
3482 expr = fold_non_dependent_expr (const_expr);
3483 const_expr = integral_constant_value (expr);
3485 while (expr != const_expr);
3490 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
3491 must be a function or a pointer-to-function type, as specified
3492 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
3493 and check that the resulting function has external linkage. */
3496 convert_nontype_argument_function (tree type, tree expr)
3501 fn = instantiate_type (type, fns, tf_none);
3502 if (fn == error_mark_node)
3503 return error_mark_node;
3506 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
3507 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
3508 if (TREE_CODE (fn_no_ptr) == BASELINK)
3509 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
3511 /* [temp.arg.nontype]/1
3513 A template-argument for a non-type, non-template template-parameter
3516 -- the address of an object or function with external linkage. */
3517 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
3519 error ("%qE is not a valid template argument for type %qT "
3520 "because function %qD has not external linkage",
3521 expr, type, fn_no_ptr);
3528 /* Attempt to convert the non-type template parameter EXPR to the
3529 indicated TYPE. If the conversion is successful, return the
3530 converted value. If the conversion is unsuccessful, return
3531 NULL_TREE if we issued an error message, or error_mark_node if we
3532 did not. We issue error messages for out-and-out bad template
3533 parameters, but not simply because the conversion failed, since we
3534 might be just trying to do argument deduction. Both TYPE and EXPR
3535 must be non-dependent.
3537 The conversion follows the special rules described in
3538 [temp.arg.nontype], and it is much more strict than an implicit
3541 This function is called twice for each template argument (see
3542 lookup_template_class for a more accurate description of this
3543 problem). This means that we need to handle expressions which
3544 are not valid in a C++ source, but can be created from the
3545 first call (for instance, casts to perform conversions). These
3546 hacks can go away after we fix the double coercion problem. */
3549 convert_nontype_argument (tree type, tree expr)
3553 /* Detect immediately string literals as invalid non-type argument.
3554 This special-case is not needed for correctness (we would easily
3555 catch this later), but only to provide better diagnostic for this
3556 common user mistake. As suggested by DR 100, we do not mention
3557 linkage issues in the diagnostic as this is not the point. */
3558 if (TREE_CODE (expr) == STRING_CST)
3560 error ("%qE is not a valid template argument for type %qT "
3561 "because string literals can never be used in this context",
3566 /* If we are in a template, EXPR may be non-dependent, but still
3567 have a syntactic, rather than semantic, form. For example, EXPR
3568 might be a SCOPE_REF, rather than the VAR_DECL to which the
3569 SCOPE_REF refers. Preserving the qualifying scope is necessary
3570 so that access checking can be performed when the template is
3571 instantiated -- but here we need the resolved form so that we can
3572 convert the argument. */
3573 expr = fold_non_dependent_expr (expr);
3574 if (error_operand_p (expr))
3575 return error_mark_node;
3576 expr_type = TREE_TYPE (expr);
3578 /* HACK: Due to double coercion, we can get a
3579 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
3580 which is the tree that we built on the first call (see
3581 below when coercing to reference to object or to reference to
3582 function). We just strip everything and get to the arg.
3583 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
3585 if (TREE_CODE (expr) == NOP_EXPR)
3587 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
3589 /* ??? Maybe we could use convert_from_reference here, but we
3590 would need to relax its constraints because the NOP_EXPR
3591 could actually change the type to something more cv-qualified,
3592 and this is not folded by convert_from_reference. */
3593 tree addr = TREE_OPERAND (expr, 0);
3594 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
3595 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
3596 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
3597 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3598 (TREE_TYPE (expr_type),
3599 TREE_TYPE (TREE_TYPE (addr))));
3601 expr = TREE_OPERAND (addr, 0);
3602 expr_type = TREE_TYPE (expr);
3605 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
3606 parameter is a pointer to object, through decay and
3607 qualification conversion. Let's strip everything. */
3608 else if (TYPE_PTROBV_P (type))
3611 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
3612 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
3613 /* Skip the ADDR_EXPR only if it is part of the decay for
3614 an array. Otherwise, it is part of the original argument
3615 in the source code. */
3616 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
3617 expr = TREE_OPERAND (expr, 0);
3618 expr_type = TREE_TYPE (expr);
3622 /* [temp.arg.nontype]/5, bullet 1
3624 For a non-type template-parameter of integral or enumeration type,
3625 integral promotions (_conv.prom_) and integral conversions
3626 (_conv.integral_) are applied. */
3627 if (INTEGRAL_TYPE_P (type))
3629 if (!INTEGRAL_TYPE_P (expr_type))
3630 return error_mark_node;
3632 expr = fold_decl_constant_value (expr);
3633 /* Notice that there are constant expressions like '4 % 0' which
3634 do not fold into integer constants. */
3635 if (TREE_CODE (expr) != INTEGER_CST)
3637 error ("%qE is not a valid template argument for type %qT "
3638 "because it is a non-constant expression", expr, type);
3642 /* At this point, an implicit conversion does what we want,
3643 because we already know that the expression is of integral
3645 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
3646 if (expr == error_mark_node)
3647 return error_mark_node;
3649 /* Conversion was allowed: fold it to a bare integer constant. */
3652 /* [temp.arg.nontype]/5, bullet 2
3654 For a non-type template-parameter of type pointer to object,
3655 qualification conversions (_conv.qual_) and the array-to-pointer
3656 conversion (_conv.array_) are applied. */
3657 else if (TYPE_PTROBV_P (type))
3659 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
3661 A template-argument for a non-type, non-template template-parameter
3662 shall be one of: [...]
3664 -- the name of a non-type template-parameter;
3665 -- the address of an object or function with external linkage, [...]
3666 expressed as "& id-expression" where the & is optional if the name
3667 refers to a function or array, or if the corresponding
3668 template-parameter is a reference.
3670 Here, we do not care about functions, as they are invalid anyway
3671 for a parameter of type pointer-to-object. */
3673 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
3674 /* Non-type template parameters are OK. */
3676 else if (TREE_CODE (expr) != ADDR_EXPR
3677 && TREE_CODE (expr_type) != ARRAY_TYPE)
3679 if (TREE_CODE (expr) == VAR_DECL)
3681 error ("%qD is not a valid template argument "
3682 "because %qD is a variable, not the address of "
3687 /* Other values, like integer constants, might be valid
3688 non-type arguments of some other type. */
3689 return error_mark_node;
3695 decl = ((TREE_CODE (expr) == ADDR_EXPR)
3696 ? TREE_OPERAND (expr, 0) : expr);
3697 if (TREE_CODE (decl) != VAR_DECL)
3699 error ("%qE is not a valid template argument of type %qT "
3700 "because %qE is not a variable",
3704 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
3706 error ("%qE is not a valid template argument of type %qT "
3707 "because %qD does not have external linkage",
3713 expr = decay_conversion (expr);
3714 if (expr == error_mark_node)
3715 return error_mark_node;
3717 expr = perform_qualification_conversions (type, expr);
3718 if (expr == error_mark_node)
3719 return error_mark_node;
3721 /* [temp.arg.nontype]/5, bullet 3
3723 For a non-type template-parameter of type reference to object, no
3724 conversions apply. The type referred to by the reference may be more
3725 cv-qualified than the (otherwise identical) type of the
3726 template-argument. The template-parameter is bound directly to the
3727 template-argument, which must be an lvalue. */
3728 else if (TYPE_REF_OBJ_P (type))
3730 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
3732 return error_mark_node;
3734 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
3736 error ("%qE is not a valid template argument for type %qT "
3737 "because of conflicts in cv-qualification", expr, type);
3741 if (!real_lvalue_p (expr))
3743 error ("%qE is not a valid template argument for type %qT "
3744 "because it is not an lvalue", expr, type);
3748 /* [temp.arg.nontype]/1
3750 A template-argument for a non-type, non-template template-parameter
3751 shall be one of: [...]
3753 -- the address of an object or function with external linkage. */
3754 if (!DECL_EXTERNAL_LINKAGE_P (expr))
3756 error ("%qE is not a valid template argument for type %qT "
3757 "because object %qD has not external linkage",
3762 expr = build_nop (type, build_address (expr));
3764 /* [temp.arg.nontype]/5, bullet 4
3766 For a non-type template-parameter of type pointer to function, only
3767 the function-to-pointer conversion (_conv.func_) is applied. If the
3768 template-argument represents a set of overloaded functions (or a
3769 pointer to such), the matching function is selected from the set
3771 else if (TYPE_PTRFN_P (type))
3773 /* If the argument is a template-id, we might not have enough
3774 context information to decay the pointer. */
3775 if (!type_unknown_p (expr_type))
3777 expr = decay_conversion (expr);
3778 if (expr == error_mark_node)
3779 return error_mark_node;
3782 expr = convert_nontype_argument_function (type, expr);
3783 if (!expr || expr == error_mark_node)
3786 /* [temp.arg.nontype]/5, bullet 5
3788 For a non-type template-parameter of type reference to function, no
3789 conversions apply. If the template-argument represents a set of
3790 overloaded functions, the matching function is selected from the set
3792 else if (TYPE_REFFN_P (type))
3794 if (TREE_CODE (expr) == ADDR_EXPR)
3796 error ("%qE is not a valid template argument for type %qT "
3797 "because it is a pointer", expr, type);
3798 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
3802 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
3803 if (!expr || expr == error_mark_node)
3806 expr = build_nop (type, build_address (expr));
3808 /* [temp.arg.nontype]/5, bullet 6
3810 For a non-type template-parameter of type pointer to member function,
3811 no conversions apply. If the template-argument represents a set of
3812 overloaded member functions, the matching member function is selected
3813 from the set (_over.over_). */
3814 else if (TYPE_PTRMEMFUNC_P (type))
3816 expr = instantiate_type (type, expr, tf_none);
3817 if (expr == error_mark_node)
3818 return error_mark_node;
3820 /* There is no way to disable standard conversions in
3821 resolve_address_of_overloaded_function (called by
3822 instantiate_type). It is possible that the call succeeded by
3823 converting &B::I to &D::I (where B is a base of D), so we need
3824 to reject this conversion here.
3826 Actually, even if there was a way to disable standard conversions,
3827 it would still be better to reject them here so that we can
3828 provide a superior diagnostic. */
3829 if (!same_type_p (TREE_TYPE (expr), type))
3831 /* Make sure we are just one standard conversion off. */
3832 gcc_assert (can_convert (type, TREE_TYPE (expr)));
3833 error ("%qE is not a valid template argument for type %qT "
3834 "because it is of type %qT", expr, type,
3836 inform ("standard conversions are not allowed in this context");
3840 /* [temp.arg.nontype]/5, bullet 7
3842 For a non-type template-parameter of type pointer to data member,
3843 qualification conversions (_conv.qual_) are applied. */
3844 else if (TYPE_PTRMEM_P (type))
3846 expr = perform_qualification_conversions (type, expr);
3847 if (expr == error_mark_node)
3850 /* A template non-type parameter must be one of the above. */
3854 /* Sanity check: did we actually convert the argument to the
3856 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
3861 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3862 template template parameters. Both PARM_PARMS and ARG_PARMS are
3863 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3866 Consider the example:
3867 template <class T> class A;
3868 template<template <class U> class TT> class B;
3870 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
3871 the parameters to A, and OUTER_ARGS contains A. */
3874 coerce_template_template_parms (tree parm_parms,
3876 tsubst_flags_t complain,
3880 int nparms, nargs, i;
3883 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
3884 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
3886 nparms = TREE_VEC_LENGTH (parm_parms);
3887 nargs = TREE_VEC_LENGTH (arg_parms);
3889 if (nargs != nparms)
3892 for (i = 0; i < nparms; ++i)
3894 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
3895 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
3898 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3899 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3901 if (arg == NULL_TREE || arg == error_mark_node
3902 || parm == NULL_TREE || parm == error_mark_node)
3905 if (TREE_CODE (arg) != TREE_CODE (parm))
3908 switch (TREE_CODE (parm))
3914 /* We encounter instantiations of templates like
3915 template <template <template <class> class> class TT>
3918 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3919 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3921 if (!coerce_template_template_parms
3922 (parmparm, argparm, complain, in_decl, outer_args))
3928 /* The tsubst call is used to handle cases such as
3930 template <int> class C {};
3931 template <class T, template <T> class TT> class D {};
3934 i.e. the parameter list of TT depends on earlier parameters. */
3935 if (!dependent_type_p (TREE_TYPE (arg))
3937 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3949 /* Convert the indicated template ARG as necessary to match the
3950 indicated template PARM. Returns the converted ARG, or
3951 error_mark_node if the conversion was unsuccessful. Error and
3952 warning messages are issued under control of COMPLAIN. This
3953 conversion is for the Ith parameter in the parameter list. ARGS is
3954 the full set of template arguments deduced so far. */
3957 convert_template_argument (tree parm,
3960 tsubst_flags_t complain,
3965 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3967 if (TREE_CODE (arg) == TREE_LIST
3968 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3970 /* The template argument was the name of some
3971 member function. That's usually
3972 invalid, but static members are OK. In any
3973 case, grab the underlying fields/functions
3974 and issue an error later if required. */
3975 arg = TREE_VALUE (arg);
3976 TREE_TYPE (arg) = unknown_type_node;
3979 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3980 requires_type = (TREE_CODE (parm) == TYPE_DECL
3981 || requires_tmpl_type);
3983 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3984 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3985 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3986 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3989 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3990 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3991 arg = TYPE_STUB_DECL (arg);
3993 is_type = TYPE_P (arg) || is_tmpl_type;
3995 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3996 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3998 pedwarn ("to refer to a type member of a template parameter, "
3999 "use %<typename %E%>", arg);
4001 arg = make_typename_type (TREE_OPERAND (arg, 0),
4002 TREE_OPERAND (arg, 1),
4004 complain & tf_error);
4007 if (is_type != requires_type)
4011 if (complain & tf_error)
4013 error ("type/value mismatch at argument %d in template "
4014 "parameter list for %qD",
4017 error (" expected a constant of type %qT, got %qT",
4019 (is_tmpl_type ? DECL_NAME (arg) : arg));
4020 else if (requires_tmpl_type)
4021 error (" expected a class template, got %qE", arg);
4023 error (" expected a type, got %qE", arg);
4026 return error_mark_node;
4028 if (is_tmpl_type ^ requires_tmpl_type)
4030 if (in_decl && (complain & tf_error))
4032 error ("type/value mismatch at argument %d in template "
4033 "parameter list for %qD",
4036 error (" expected a type, got %qT", DECL_NAME (arg));
4038 error (" expected a class template, got %qT", arg);
4040 return error_mark_node;
4045 if (requires_tmpl_type)
4047 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4048 /* The number of argument required is not known yet.
4049 Just accept it for now. */
4050 val = TREE_TYPE (arg);
4053 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4054 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4056 if (coerce_template_template_parms (parmparm, argparm,
4062 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4064 if (val != error_mark_node
4065 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4066 val = TREE_TYPE (val);
4070 if (in_decl && (complain & tf_error))
4072 error ("type/value mismatch at argument %d in "
4073 "template parameter list for %qD",
4075 error (" expected a template of type %qD, got %qD",
4079 val = error_mark_node;
4085 /* We only form one instance of each template specialization.
4086 Therefore, if we use a non-canonical variant (i.e., a
4087 typedef), any future messages referring to the type will use
4088 the typedef, which is confusing if those future uses do not
4089 themselves also use the typedef. */
4091 val = canonical_type_variant (val);
4095 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4097 if (invalid_nontype_parm_type_p (t, complain))
4098 return error_mark_node;
4100 if (!uses_template_parms (arg) && !uses_template_parms (t))
4101 /* We used to call digest_init here. However, digest_init
4102 will report errors, which we don't want when complain
4103 is zero. More importantly, digest_init will try too
4104 hard to convert things: for example, `0' should not be
4105 converted to pointer type at this point according to
4106 the standard. Accepting this is not merely an
4107 extension, since deciding whether or not these
4108 conversions can occur is part of determining which
4109 function template to call, or whether a given explicit
4110 argument specification is valid. */
4111 val = convert_nontype_argument (t, arg);
4115 if (val == NULL_TREE)
4116 val = error_mark_node;
4117 else if (val == error_mark_node && (complain & tf_error))
4118 error ("could not convert template argument %qE to %qT", arg, t);
4124 /* Convert all template arguments to their appropriate types, and
4125 return a vector containing the innermost resulting template
4126 arguments. If any error occurs, return error_mark_node. Error and
4127 warning messages are issued under control of COMPLAIN.
4129 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
4130 for arguments not specified in ARGS. Otherwise, if
4131 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
4132 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
4133 USE_DEFAULT_ARGS is false, then all arguments must be specified in
4137 coerce_template_parms (tree parms,
4140 tsubst_flags_t complain,
4141 bool require_all_args,
4142 bool use_default_args)
4144 int nparms, nargs, i, lost = 0;
4147 tree new_inner_args;
4148 bool saved_skip_evaluation;
4150 inner_args = INNERMOST_TEMPLATE_ARGS (args);
4151 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4152 nparms = TREE_VEC_LENGTH (parms);
4157 && (!use_default_args
4158 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
4159 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
4161 if (complain & tf_error)
4163 error ("wrong number of template arguments (%d, should be %d)",
4167 error ("provided for %q+D", in_decl);
4170 return error_mark_node;
4173 /* We need to evaluate the template arguments, even though this
4174 template-id may be nested within a "sizeof". */
4175 saved_skip_evaluation = skip_evaluation;
4176 skip_evaluation = false;
4177 new_inner_args = make_tree_vec (nparms);
4178 new_args = add_outermost_template_args (args, new_inner_args);
4179 for (i = 0; i < nparms; i++)
4184 /* Get the Ith template parameter. */
4185 parm = TREE_VEC_ELT (parms, i);
4187 if (parm == error_mark_node)
4189 TREE_VEC_ELT (new_inner_args, i) = error_mark_node;
4193 /* Calculate the Ith argument. */
4195 arg = TREE_VEC_ELT (inner_args, i);
4196 else if (require_all_args)
4197 /* There must be a default arg in this case. */
4198 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
4204 if (arg == error_mark_node)
4206 if (complain & tf_error)
4207 error ("template argument %d is invalid", i + 1);
4210 arg = convert_template_argument (TREE_VALUE (parm),
4211 arg, new_args, complain, i,
4214 if (arg == error_mark_node)
4216 TREE_VEC_ELT (new_inner_args, i) = arg;
4218 skip_evaluation = saved_skip_evaluation;
4221 return error_mark_node;
4223 return new_inner_args;
4226 /* Returns 1 if template args OT and NT are equivalent. */
4229 template_args_equal (tree ot, tree nt)
4234 if (TREE_CODE (nt) == TREE_VEC)
4235 /* For member templates */
4236 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
4237 else if (TYPE_P (nt))
4238 return TYPE_P (ot) && same_type_p (ot, nt);
4239 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
4242 return cp_tree_equal (ot, nt);
4245 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
4246 of template arguments. Returns 0 otherwise. */
4249 comp_template_args (tree oldargs, tree newargs)
4253 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
4256 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
4258 tree nt = TREE_VEC_ELT (newargs, i);
4259 tree ot = TREE_VEC_ELT (oldargs, i);
4261 if (! template_args_equal (ot, nt))
4267 /* Given class template name and parameter list, produce a user-friendly name
4268 for the instantiation. */
4271 mangle_class_name_for_template (const char* name, tree parms, tree arglist)
4273 static struct obstack scratch_obstack;
4274 static char *scratch_firstobj;
4277 if (!scratch_firstobj)
4278 gcc_obstack_init (&scratch_obstack);
4280 obstack_free (&scratch_obstack, scratch_firstobj);
4281 scratch_firstobj = (char *) obstack_alloc (&scratch_obstack, 1);
4283 #define ccat(C) obstack_1grow (&scratch_obstack, (C));
4284 #define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
4288 nparms = TREE_VEC_LENGTH (parms);
4289 arglist = INNERMOST_TEMPLATE_ARGS (arglist);
4290 gcc_assert (nparms == TREE_VEC_LENGTH (arglist));
4291 for (i = 0; i < nparms; i++)
4296 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4297 arg = TREE_VEC_ELT (arglist, i);
4299 if (parm == error_mark_node)
4305 if (TREE_CODE (parm) == TYPE_DECL)
4307 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4310 else if (TREE_CODE (parm) == TEMPLATE_DECL)
4312 if (TREE_CODE (arg) == TEMPLATE_DECL)
4314 /* Already substituted with real template. Just output
4315 the template name here */
4316 tree context = DECL_CONTEXT (arg);
4319 /* The template may be defined in a namespace, or
4320 may be a member template. */
4321 gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
4322 || CLASS_TYPE_P (context));
4323 cat (decl_as_string (DECL_CONTEXT (arg),
4324 TFF_PLAIN_IDENTIFIER));
4327 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
4330 /* Output the parameter declaration. */
4331 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4335 gcc_assert (TREE_CODE (parm) == PARM_DECL);
4337 /* No need to check arglist against parmlist here; we did that
4338 in coerce_template_parms, called from lookup_template_class. */
4339 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
4342 char *bufp = obstack_next_free (&scratch_obstack);
4344 while (bufp[offset - 1] == ' ')
4346 obstack_blank_fast (&scratch_obstack, offset);
4348 /* B<C<char> >, not B<C<char>> */
4349 if (bufp[offset - 1] == '>')
4354 return (char *) obstack_base (&scratch_obstack);
4358 classtype_mangled_name (tree t)
4360 if (CLASSTYPE_TEMPLATE_INFO (t)
4361 /* Specializations have already had their names set up in
4362 lookup_template_class. */
4363 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4365 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4367 /* For non-primary templates, the template parameters are
4368 implicit from their surrounding context. */
4369 if (PRIMARY_TEMPLATE_P (tmpl))
4371 tree name = DECL_NAME (tmpl);
4372 char *mangled_name = mangle_class_name_for_template
4373 (IDENTIFIER_POINTER (name),
4374 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4375 CLASSTYPE_TI_ARGS (t));
4376 tree id = get_identifier (mangled_name);
4377 IDENTIFIER_TEMPLATE (id) = name;
4382 return TYPE_IDENTIFIER (t);
4386 add_pending_template (tree d)
4388 tree ti = (TYPE_P (d)
4389 ? CLASSTYPE_TEMPLATE_INFO (d)
4390 : DECL_TEMPLATE_INFO (d));
4394 if (TI_PENDING_TEMPLATE_FLAG (ti))
4397 /* We are called both from instantiate_decl, where we've already had a
4398 tinst_level pushed, and instantiate_template, where we haven't.
4400 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4403 push_tinst_level (d);
4405 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4406 if (last_pending_template)
4407 TREE_CHAIN (last_pending_template) = pt;
4409 pending_templates = pt;
4411 last_pending_template = pt;
4413 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4420 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4421 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4422 documentation for TEMPLATE_ID_EXPR. */
4425 lookup_template_function (tree fns, tree arglist)
4429 if (fns == error_mark_node || arglist == error_mark_node)
4430 return error_mark_node;
4432 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
4433 gcc_assert (fns && (is_overloaded_fn (fns)
4434 || TREE_CODE (fns) == IDENTIFIER_NODE));
4436 if (BASELINK_P (fns))
4438 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
4440 BASELINK_FUNCTIONS (fns),
4445 type = TREE_TYPE (fns);
4446 if (TREE_CODE (fns) == OVERLOAD || !type)
4447 type = unknown_type_node;
4449 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
4452 /* Within the scope of a template class S<T>, the name S gets bound
4453 (in build_self_reference) to a TYPE_DECL for the class, not a
4454 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4455 or one of its enclosing classes, and that type is a template,
4456 return the associated TEMPLATE_DECL. Otherwise, the original
4457 DECL is returned. */
4460 maybe_get_template_decl_from_type_decl (tree decl)
4462 return (decl != NULL_TREE
4463 && TREE_CODE (decl) == TYPE_DECL
4464 && DECL_ARTIFICIAL (decl)
4465 && CLASS_TYPE_P (TREE_TYPE (decl))
4466 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4467 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4470 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4471 parameters, find the desired type.
4473 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4475 IN_DECL, if non-NULL, is the template declaration we are trying to
4478 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4479 the class we are looking up.
4481 Issue error and warning messages under control of COMPLAIN.
4483 If the template class is really a local class in a template
4484 function, then the FUNCTION_CONTEXT is the function in which it is
4487 ??? Note that this function is currently called *twice* for each
4488 template-id: the first time from the parser, while creating the
4489 incomplete type (finish_template_type), and the second type during the
4490 real instantiation (instantiate_template_class). This is surely something
4491 that we want to avoid. It also causes some problems with argument
4492 coercion (see convert_nontype_argument for more information on this). */
4495 lookup_template_class (tree d1,
4500 tsubst_flags_t complain)
4502 tree template = NULL_TREE, parmlist;
4505 timevar_push (TV_NAME_LOOKUP);
4507 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4509 tree value = innermost_non_namespace_value (d1);
4510 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
4515 push_decl_namespace (context);
4516 template = lookup_name (d1);
4517 template = maybe_get_template_decl_from_type_decl (template);
4519 pop_decl_namespace ();
4522 context = DECL_CONTEXT (template);
4524 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4526 tree type = TREE_TYPE (d1);
4528 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4529 an implicit typename for the second A. Deal with it. */
4530 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4531 type = TREE_TYPE (type);
4533 if (CLASSTYPE_TEMPLATE_INFO (type))
4535 template = CLASSTYPE_TI_TEMPLATE (type);
4536 d1 = DECL_NAME (template);
4539 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4540 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4542 template = TYPE_TI_TEMPLATE (d1);
4543 d1 = DECL_NAME (template);
4545 else if (TREE_CODE (d1) == TEMPLATE_DECL
4546 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4549 d1 = DECL_NAME (template);
4550 context = DECL_CONTEXT (template);
4553 /* Issue an error message if we didn't find a template. */
4556 if (complain & tf_error)
4557 error ("%qT is not a template", d1);
4558 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4561 if (TREE_CODE (template) != TEMPLATE_DECL
4562 /* Make sure it's a user visible template, if it was named by
4564 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4565 && !PRIMARY_TEMPLATE_P (template)))
4567 if (complain & tf_error)
4569 error ("non-template type %qT used as a template", d1);
4571 error ("for template declaration %q+D", in_decl);
4573 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4576 complain &= ~tf_user;
4578 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4580 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4581 template arguments */
4586 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4588 /* Consider an example where a template template parameter declared as
4590 template <class T, class U = std::allocator<T> > class TT
4592 The template parameter level of T and U are one level larger than
4593 of TT. To proper process the default argument of U, say when an
4594 instantiation `TT<int>' is seen, we need to build the full
4595 arguments containing {int} as the innermost level. Outer levels,
4596 available when not appearing as default template argument, can be
4597 obtained from `current_template_args ()'.
4599 Suppose that TT is later substituted with std::vector. The above
4600 instantiation is `TT<int, std::allocator<T> >' with TT at
4601 level 1, and T at level 2, while the template arguments at level 1
4602 becomes {std::vector} and the inner level 2 is {int}. */
4604 if (current_template_parms)
4605 arglist = add_to_template_args (current_template_args (), arglist);
4607 arglist2 = coerce_template_parms (parmlist, arglist, template,
4609 /*require_all_args=*/true,
4610 /*use_default_args=*/true);
4611 if (arglist2 == error_mark_node
4612 || (!uses_template_parms (arglist2)
4613 && check_instantiated_args (template, arglist2, complain)))
4614 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4616 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4617 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4621 tree template_type = TREE_TYPE (template);
4624 tree found = NULL_TREE;
4627 int is_partial_instantiation;
4629 gen_tmpl = most_general_template (template);
4630 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4631 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4632 arg_depth = TMPL_ARGS_DEPTH (arglist);
4634 if (arg_depth == 1 && parm_depth > 1)
4636 /* We've been given an incomplete set of template arguments.
4639 template <class T> struct S1 {
4640 template <class U> struct S2 {};
4641 template <class U> struct S2<U*> {};
4644 we will be called with an ARGLIST of `U*', but the
4645 TEMPLATE will be `template <class T> template
4646 <class U> struct S1<T>::S2'. We must fill in the missing
4649 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4651 arg_depth = TMPL_ARGS_DEPTH (arglist);
4654 /* Now we should have enough arguments. */
4655 gcc_assert (parm_depth == arg_depth);
4657 /* From here on, we're only interested in the most general
4659 template = gen_tmpl;
4661 /* Calculate the BOUND_ARGS. These will be the args that are
4662 actually tsubst'd into the definition to create the
4666 /* We have multiple levels of arguments to coerce, at once. */
4668 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4670 tree bound_args = make_tree_vec (parm_depth);
4672 for (i = saved_depth,
4673 t = DECL_TEMPLATE_PARMS (template);
4674 i > 0 && t != NULL_TREE;
4675 --i, t = TREE_CHAIN (t))
4677 tree a = coerce_template_parms (TREE_VALUE (t),
4680 /*require_all_args=*/true,
4681 /*use_default_args=*/true);
4683 /* Don't process further if one of the levels fails. */
4684 if (a == error_mark_node)
4686 /* Restore the ARGLIST to its full size. */
4687 TREE_VEC_LENGTH (arglist) = saved_depth;
4688 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4691 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4693 /* We temporarily reduce the length of the ARGLIST so
4694 that coerce_template_parms will see only the arguments
4695 corresponding to the template parameters it is
4697 TREE_VEC_LENGTH (arglist)--;
4700 /* Restore the ARGLIST to its full size. */
4701 TREE_VEC_LENGTH (arglist) = saved_depth;
4703 arglist = bound_args;
4707 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4708 INNERMOST_TEMPLATE_ARGS (arglist),
4711 /*require_all_args=*/true,
4712 /*use_default_args=*/true);
4714 if (arglist == error_mark_node)
4715 /* We were unable to bind the arguments. */
4716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4718 /* In the scope of a template class, explicit references to the
4719 template class refer to the type of the template, not any
4720 instantiation of it. For example, in:
4722 template <class T> class C { void f(C<T>); }
4724 the `C<T>' is just the same as `C'. Outside of the
4725 class, however, such a reference is an instantiation. */
4726 if (comp_template_args (TYPE_TI_ARGS (template_type),
4729 found = template_type;
4731 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4735 for (ctx = current_class_type;
4736 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4738 ? TYPE_CONTEXT (ctx)
4739 : DECL_CONTEXT (ctx)))
4740 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4743 /* We're not in the scope of the class, so the
4744 TEMPLATE_TYPE is not the type we want after all. */
4750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4752 /* If we already have this specialization, return it. */
4753 found = retrieve_specialization (template, arglist,
4754 /*class_specializations_p=*/false);
4756 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4758 /* This type is a "partial instantiation" if any of the template
4759 arguments still involve template parameters. Note that we set
4760 IS_PARTIAL_INSTANTIATION for partial specializations as
4762 is_partial_instantiation = uses_template_parms (arglist);
4764 /* If the deduced arguments are invalid, then the binding
4766 if (!is_partial_instantiation
4767 && check_instantiated_args (template,
4768 INNERMOST_TEMPLATE_ARGS (arglist),
4770 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4772 if (!is_partial_instantiation
4773 && !PRIMARY_TEMPLATE_P (template)
4774 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4776 found = xref_tag_from_type (TREE_TYPE (template),
4777 DECL_NAME (template),
4778 /*tag_scope=*/ts_global);
4779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4782 context = tsubst (DECL_CONTEXT (template), arglist,
4785 context = global_namespace;
4787 /* Create the type. */
4788 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4790 if (!is_partial_instantiation)
4792 set_current_access_from_decl (TYPE_NAME (template_type));
4793 t = start_enum (TYPE_IDENTIFIER (template_type));
4796 /* We don't want to call start_enum for this type, since
4797 the values for the enumeration constants may involve
4798 template parameters. And, no one should be interested
4799 in the enumeration constants for such a type. */
4800 t = make_node (ENUMERAL_TYPE);
4804 t = make_aggr_type (TREE_CODE (template_type));
4805 CLASSTYPE_DECLARED_CLASS (t)
4806 = CLASSTYPE_DECLARED_CLASS (template_type);
4807 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4808 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4810 /* A local class. Make sure the decl gets registered properly. */
4811 if (context == current_function_decl)
4812 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
4815 /* If we called start_enum or pushtag above, this information
4816 will already be set up. */
4819 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4821 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4822 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4823 TYPE_STUB_DECL (t) = type_decl;
4824 DECL_SOURCE_LOCATION (type_decl)
4825 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4828 type_decl = TYPE_NAME (t);
4830 TREE_PRIVATE (type_decl)
4831 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4832 TREE_PROTECTED (type_decl)
4833 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4834 DECL_IN_SYSTEM_HEADER (type_decl)
4835 = DECL_IN_SYSTEM_HEADER (template);
4836 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
4838 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
4839 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
4842 /* Set up the template information. We have to figure out which
4843 template is the immediate parent if this is a full
4845 if (parm_depth == 1 || is_partial_instantiation
4846 || !PRIMARY_TEMPLATE_P (template))
4847 /* This case is easy; there are no member templates involved. */
4851 /* This is a full instantiation of a member template. Look
4852 for a partial instantiation of which this is an instance. */
4854 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4855 found; found = TREE_CHAIN (found))
4858 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4860 /* We only want partial instantiations, here, not
4861 specializations or full instantiations. */
4862 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4863 || !uses_template_parms (TREE_VALUE (found)))
4866 /* Temporarily reduce by one the number of levels in the
4867 ARGLIST and in FOUND so as to avoid comparing the
4868 last set of arguments. */
4869 TREE_VEC_LENGTH (arglist)--;
4870 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4872 /* See if the arguments match. If they do, then TMPL is
4873 the partial instantiation we want. */
4874 success = comp_template_args (TREE_PURPOSE (found), arglist);
4876 /* Restore the argument vectors to their full size. */
4877 TREE_VEC_LENGTH (arglist)++;
4878 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4889 /* There was no partial instantiation. This happens
4890 where C<T> is a member template of A<T> and it's used
4893 template <typename T> struct B { A<T>::C<int> m; };
4896 Create the partial instantiation.
4898 TREE_VEC_LENGTH (arglist)--;
4899 found = tsubst (template, arglist, complain, NULL_TREE);
4900 TREE_VEC_LENGTH (arglist)++;
4904 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4905 DECL_TEMPLATE_INSTANTIATIONS (template)
4906 = tree_cons (arglist, t,
4907 DECL_TEMPLATE_INSTANTIATIONS (template));
4909 if (TREE_CODE (t) == ENUMERAL_TYPE
4910 && !is_partial_instantiation)
4911 /* Now that the type has been registered on the instantiations
4912 list, we set up the enumerators. Because the enumeration
4913 constants may involve the enumeration type itself, we make
4914 sure to register the type first, and then create the
4915 constants. That way, doing tsubst_expr for the enumeration
4916 constants won't result in recursive calls here; we'll find
4917 the instantiation and exit above. */
4918 tsubst_enum (template_type, t, arglist);
4920 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4922 if (TREE_CODE (t) != ENUMERAL_TYPE)
4923 DECL_NAME (type_decl) = classtype_mangled_name (t);
4924 if (is_partial_instantiation)
4925 /* If the type makes use of template parameters, the
4926 code that generates debugging information will crash. */
4927 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4929 /* Possibly limit visibility based on template args. */
4930 TREE_PUBLIC (type_decl) = 1;
4931 determine_visibility (type_decl);
4933 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4935 timevar_pop (TV_NAME_LOOKUP);
4942 struct pointer_set_t *visited;
4945 /* Called from for_each_template_parm via walk_tree. */
4948 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
4951 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4952 tree_fn_t fn = pfd->fn;
4953 void *data = pfd->data;
4956 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4957 return error_mark_node;
4959 switch (TREE_CODE (t))
4962 if (TYPE_PTRMEMFUNC_P (t))
4968 if (!TYPE_TEMPLATE_INFO (t))
4970 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4971 fn, data, pfd->visited))
4972 return error_mark_node;
4976 /* Since we're not going to walk subtrees, we have to do this
4978 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4980 return error_mark_node;
4984 /* Check the return type. */
4985 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4986 return error_mark_node;
4988 /* Check the parameter types. Since default arguments are not
4989 instantiated until they are needed, the TYPE_ARG_TYPES may
4990 contain expressions that involve template parameters. But,
4991 no-one should be looking at them yet. And, once they're
4992 instantiated, they don't contain template parameters, so
4993 there's no point in looking at them then, either. */
4997 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4998 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
5000 return error_mark_node;
5002 /* Since we've already handled the TYPE_ARG_TYPES, we don't
5003 want walk_tree walking into them itself. */
5009 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
5011 return error_mark_node;
5016 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
5017 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
5019 return error_mark_node;
5024 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
5025 && for_each_template_parm (DECL_INITIAL (t), fn, data,
5027 return error_mark_node;
5028 if (DECL_CONTEXT (t)
5029 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
5031 return error_mark_node;
5034 case BOUND_TEMPLATE_TEMPLATE_PARM:
5035 /* Record template parameters such as `T' inside `TT<T>'. */
5036 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
5037 return error_mark_node;
5040 case TEMPLATE_TEMPLATE_PARM:
5041 case TEMPLATE_TYPE_PARM:
5042 case TEMPLATE_PARM_INDEX:
5043 if (fn && (*fn)(t, data))
5044 return error_mark_node;
5046 return error_mark_node;
5050 /* A template template parameter is encountered. */
5051 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
5052 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5053 return error_mark_node;
5055 /* Already substituted template template parameter */
5061 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
5062 data, pfd->visited))
5063 return error_mark_node;
5067 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
5068 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
5069 (TREE_TYPE (t)), fn, data,
5071 return error_mark_node;
5076 /* If there's no type, then this thing must be some expression
5077 involving template parameters. */
5078 if (!fn && !TREE_TYPE (t))
5079 return error_mark_node;
5084 case REINTERPRET_CAST_EXPR:
5085 case CONST_CAST_EXPR:
5086 case STATIC_CAST_EXPR:
5087 case DYNAMIC_CAST_EXPR:
5091 case PSEUDO_DTOR_EXPR:
5093 return error_mark_node;
5097 /* If we do not handle this case specially, we end up walking
5098 the BINFO hierarchy, which is circular, and therefore
5099 confuses walk_tree. */
5101 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
5103 return error_mark_node;
5110 /* We didn't find any template parameters we liked. */
5114 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
5115 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
5116 call FN with the parameter and the DATA.
5117 If FN returns nonzero, the iteration is terminated, and
5118 for_each_template_parm returns 1. Otherwise, the iteration
5119 continues. If FN never returns a nonzero value, the value
5120 returned by for_each_template_parm is 0. If FN is NULL, it is
5121 considered to be the function which always returns 1. */
5124 for_each_template_parm (tree t, tree_fn_t fn, void* data,
5125 struct pointer_set_t *visited)
5127 struct pair_fn_data pfd;
5134 /* Walk the tree. (Conceptually, we would like to walk without
5135 duplicates, but for_each_template_parm_r recursively calls
5136 for_each_template_parm, so we would need to reorganize a fair
5137 bit to use walk_tree_without_duplicates, so we keep our own
5140 pfd.visited = visited;
5142 pfd.visited = pointer_set_create ();
5143 result = walk_tree (&t,
5144 for_each_template_parm_r,
5146 pfd.visited) != NULL_TREE;
5151 pointer_set_destroy (pfd.visited);
5158 /* Returns true if T depends on any template parameter. */
5161 uses_template_parms (tree t)
5164 int saved_processing_template_decl;
5166 saved_processing_template_decl = processing_template_decl;
5167 if (!saved_processing_template_decl)
5168 processing_template_decl = 1;
5170 dependent_p = dependent_type_p (t);
5171 else if (TREE_CODE (t) == TREE_VEC)
5172 dependent_p = any_dependent_template_arguments_p (t);
5173 else if (TREE_CODE (t) == TREE_LIST)
5174 dependent_p = (uses_template_parms (TREE_VALUE (t))
5175 || uses_template_parms (TREE_CHAIN (t)));
5176 else if (TREE_CODE (t) == TYPE_DECL)
5177 dependent_p = dependent_type_p (TREE_TYPE (t));
5180 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
5181 || TREE_CODE (t) == OVERLOAD
5182 || TREE_CODE (t) == BASELINK
5183 || TREE_CODE (t) == IDENTIFIER_NODE
5184 || CONSTANT_CLASS_P (t))
5185 dependent_p = (type_dependent_expression_p (t)
5186 || value_dependent_expression_p (t));
5189 gcc_assert (t == error_mark_node);
5190 dependent_p = false;
5193 processing_template_decl = saved_processing_template_decl;
5198 /* Returns true if T depends on any template parameter with level LEVEL. */
5201 uses_template_parms_level (tree t, int level)
5203 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
5206 static int tinst_depth;
5207 extern int max_tinst_depth;
5208 #ifdef GATHER_STATISTICS
5211 static int tinst_level_tick;
5212 static int last_template_error_tick;
5214 /* We're starting to instantiate D; record the template instantiation context
5215 for diagnostics and to restore it later. */
5218 push_tinst_level (tree d)
5222 if (tinst_depth >= max_tinst_depth)
5224 /* If the instantiation in question still has unbound template parms,
5225 we don't really care if we can't instantiate it, so just return.
5226 This happens with base instantiation for implicit `typename'. */
5227 if (uses_template_parms (d))
5230 last_template_error_tick = tinst_level_tick;
5231 error ("template instantiation depth exceeds maximum of %d (use "
5232 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
5233 max_tinst_depth, d);
5235 print_instantiation_context ();
5240 new = make_node (TINST_LEVEL);
5241 TINST_DECL (new) = d;
5242 TINST_LOCATION (new) = input_location;
5243 TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
5244 TREE_CHAIN (new) = current_tinst_level;
5245 current_tinst_level = new;
5248 #ifdef GATHER_STATISTICS
5249 if (tinst_depth > depth_reached)
5250 depth_reached = tinst_depth;
5257 /* We're done instantiating this template; return to the instantiation
5261 pop_tinst_level (void)
5263 tree old = current_tinst_level;
5265 /* Restore the filename and line number stashed away when we started
5266 this instantiation. */
5267 input_location = TINST_LOCATION (old);
5268 in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
5269 current_tinst_level = TREE_CHAIN (old);
5274 /* We're instantiating a deferred template; restore the template
5275 instantiation context in which the instantiation was requested, which
5276 is one step out from LEVEL. */
5279 reopen_tinst_level (tree level)
5284 for (t = level; t; t = TREE_CHAIN (t))
5287 current_tinst_level = level;
5291 /* Returns the TINST_LEVEL which gives the original instantiation
5295 outermost_tinst_level (void)
5297 return tree_last (current_tinst_level);
5300 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
5301 vector of template arguments, as for tsubst.
5303 Returns an appropriate tsubst'd friend declaration. */
5306 tsubst_friend_function (tree decl, tree args)
5310 if (TREE_CODE (decl) == FUNCTION_DECL
5311 && DECL_TEMPLATE_INSTANTIATION (decl)
5312 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
5313 /* This was a friend declared with an explicit template
5314 argument list, e.g.:
5318 to indicate that f was a template instantiation, not a new
5319 function declaration. Now, we have to figure out what
5320 instantiation of what template. */
5322 tree template_id, arglist, fns;
5325 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
5327 /* Friend functions are looked up in the containing namespace scope.
5328 We must enter that scope, to avoid finding member functions of the
5329 current cless with same name. */
5330 push_nested_namespace (ns);
5331 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
5332 tf_warning_or_error, NULL_TREE,
5333 /*integral_constant_expression_p=*/false);
5334 pop_nested_namespace (ns);
5335 arglist = tsubst (DECL_TI_ARGS (decl), args,
5336 tf_warning_or_error, NULL_TREE);
5337 template_id = lookup_template_function (fns, arglist);
5339 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5340 tmpl = determine_specialization (template_id, new_friend,
5342 /*need_member_template=*/0,
5343 TREE_VEC_LENGTH (args),
5345 return instantiate_template (tmpl, new_args, tf_error);
5348 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5350 /* The NEW_FRIEND will look like an instantiation, to the
5351 compiler, but is not an instantiation from the point of view of
5352 the language. For example, we might have had:
5354 template <class T> struct S {
5355 template <class U> friend void f(T, U);
5358 Then, in S<int>, template <class U> void f(int, U) is not an
5359 instantiation of anything. */
5360 if (new_friend == error_mark_node)
5361 return error_mark_node;
5363 DECL_USE_TEMPLATE (new_friend) = 0;
5364 if (TREE_CODE (decl) == TEMPLATE_DECL)
5366 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
5367 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
5368 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5371 /* The mangled name for the NEW_FRIEND is incorrect. The function
5372 is not a template instantiation and should not be mangled like
5373 one. Therefore, we forget the mangling here; we'll recompute it
5374 later if we need it. */
5375 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5377 SET_DECL_RTL (new_friend, NULL_RTX);
5378 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5381 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5384 tree new_friend_template_info;
5385 tree new_friend_result_template_info;
5387 int new_friend_is_defn;
5389 /* We must save some information from NEW_FRIEND before calling
5390 duplicate decls since that function will free NEW_FRIEND if
5392 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5393 new_friend_is_defn =
5394 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5395 (template_for_substitution (new_friend)))
5397 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5399 /* This declaration is a `primary' template. */
5400 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5402 new_friend_result_template_info
5403 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5406 new_friend_result_template_info = NULL_TREE;
5408 /* Make the init_value nonzero so pushdecl knows this is a defn. */
5409 if (new_friend_is_defn)
5410 DECL_INITIAL (new_friend) = error_mark_node;
5412 /* Inside pushdecl_namespace_level, we will push into the
5413 current namespace. However, the friend function should go
5414 into the namespace of the template. */
5415 ns = decl_namespace_context (new_friend);
5416 push_nested_namespace (ns);
5417 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
5418 pop_nested_namespace (ns);
5420 if (old_decl == error_mark_node)
5421 return error_mark_node;
5423 if (old_decl != new_friend)
5425 /* This new friend declaration matched an existing
5426 declaration. For example, given:
5428 template <class T> void f(T);
5429 template <class U> class C {
5430 template <class T> friend void f(T) {}
5433 the friend declaration actually provides the definition
5434 of `f', once C has been instantiated for some type. So,
5435 old_decl will be the out-of-class template declaration,
5436 while new_friend is the in-class definition.
5438 But, if `f' was called before this point, the
5439 instantiation of `f' will have DECL_TI_ARGS corresponding
5440 to `T' but not to `U', references to which might appear
5441 in the definition of `f'. Previously, the most general
5442 template for an instantiation of `f' was the out-of-class
5443 version; now it is the in-class version. Therefore, we
5444 run through all specialization of `f', adding to their
5445 DECL_TI_ARGS appropriately. In particular, they need a
5446 new set of outer arguments, corresponding to the
5447 arguments for this class instantiation.
5449 The same situation can arise with something like this:
5452 template <class T> class C {
5456 when `C<int>' is instantiated. Now, `f(int)' is defined
5459 if (!new_friend_is_defn)
5460 /* On the other hand, if the in-class declaration does
5461 *not* provide a definition, then we don't want to alter
5462 existing definitions. We can just leave everything
5467 /* Overwrite whatever template info was there before, if
5468 any, with the new template information pertaining to
5470 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5472 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5473 reregister_specialization (new_friend,
5474 most_general_template (old_decl),
5479 tree new_friend_args;
5481 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5482 = new_friend_result_template_info;
5484 new_friend_args = TI_ARGS (new_friend_template_info);
5485 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5489 tree spec = TREE_VALUE (t);
5492 = add_outermost_template_args (new_friend_args,
5493 DECL_TI_ARGS (spec));
5496 /* Now, since specializations are always supposed to
5497 hang off of the most general template, we must move
5499 t = most_general_template (old_decl);
5502 DECL_TEMPLATE_SPECIALIZATIONS (t)
5503 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5504 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5505 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5510 /* The information from NEW_FRIEND has been merged into OLD_DECL
5511 by duplicate_decls. */
5512 new_friend = old_decl;
5517 tree context = DECL_CONTEXT (new_friend);
5521 template <class T> class C {
5522 template <class U> friend void C1<U>::f (); // case 1
5523 friend void C2<T>::f (); // case 2
5525 we only need to make sure CONTEXT is a complete type for
5526 case 2. To distinguish between the two cases, we note that
5527 CONTEXT of case 1 remains dependent type after tsubst while
5528 this isn't true for case 2. */
5529 ++processing_template_decl;
5530 dependent_p = dependent_type_p (context);
5531 --processing_template_decl;
5534 && !complete_type_or_else (context, NULL_TREE))
5535 return error_mark_node;
5537 if (COMPLETE_TYPE_P (context))
5539 /* Check to see that the declaration is really present, and,
5540 possibly obtain an improved declaration. */
5541 tree fn = check_classfn (context,
5542 new_friend, NULL_TREE);
5552 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5553 template arguments, as for tsubst.
5555 Returns an appropriate tsubst'd friend type or error_mark_node on
5559 tsubst_friend_class (tree friend_tmpl, tree args)
5565 context = DECL_CONTEXT (friend_tmpl);
5569 if (TREE_CODE (context) == NAMESPACE_DECL)
5570 push_nested_namespace (context);
5572 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5575 /* Look for a class template declaration. We look for hidden names
5576 because two friend declarations of the same template are the
5577 same. For example, in:
5580 template <typename> friend class F;
5582 template <typename> struct B {
5583 template <typename> friend class F;
5586 both F templates are the same. */
5587 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
5588 /*block_p=*/true, 0,
5589 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
5591 /* But, if we don't find one, it might be because we're in a
5592 situation like this:
5600 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5601 for `S<int>', not the TEMPLATE_DECL. */
5602 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5604 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
5605 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5608 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5610 /* The friend template has already been declared. Just
5611 check to see that the declarations match, and install any new
5612 default parameters. We must tsubst the default parameters,
5613 of course. We only need the innermost template parameters
5614 because that is all that redeclare_class_template will look
5616 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5617 > TMPL_ARGS_DEPTH (args))
5620 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5621 args, tf_warning_or_error);
5622 redeclare_class_template (TREE_TYPE (tmpl), parms);
5625 friend_type = TREE_TYPE (tmpl);
5629 /* The friend template has not already been declared. In this
5630 case, the instantiation of the template class will cause the
5631 injection of this template into the global scope. */
5632 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
5633 if (tmpl == error_mark_node)
5634 return error_mark_node;
5636 /* The new TMPL is not an instantiation of anything, so we
5637 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5638 the new type because that is supposed to be the corresponding
5639 template decl, i.e., TMPL. */
5640 DECL_USE_TEMPLATE (tmpl) = 0;
5641 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5642 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5643 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5644 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5646 /* Inject this template into the global scope. */
5647 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
5652 if (TREE_CODE (context) == NAMESPACE_DECL)
5653 pop_nested_namespace (context);
5655 pop_nested_class ();
5661 /* Returns zero if TYPE cannot be completed later due to circularity.
5662 Otherwise returns one. */
5665 can_complete_type_without_circularity (tree type)
5667 if (type == NULL_TREE || type == error_mark_node)
5669 else if (COMPLETE_TYPE_P (type))
5671 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5672 return can_complete_type_without_circularity (TREE_TYPE (type));
5673 else if (CLASS_TYPE_P (type)
5674 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5681 instantiate_class_template (tree type)
5683 tree template, args, pattern, t, member;
5688 if (type == error_mark_node)
5689 return error_mark_node;
5691 if (TYPE_BEING_DEFINED (type)
5692 || COMPLETE_TYPE_P (type)
5693 || dependent_type_p (type))
5696 /* Figure out which template is being instantiated. */
5697 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5698 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
5700 /* Determine what specialization of the original template to
5702 t = most_specialized_class (type, template);
5703 if (t == error_mark_node)
5705 TYPE_BEING_DEFINED (type) = 1;
5706 return error_mark_node;
5710 /* This TYPE is actually an instantiation of a partial
5711 specialization. We replace the innermost set of ARGS with
5712 the arguments appropriate for substitution. For example,
5715 template <class T> struct S {};
5716 template <class T> struct S<T*> {};
5718 and supposing that we are instantiating S<int*>, ARGS will
5719 presently be {int*} -- but we need {int}. */
5720 pattern = TREE_TYPE (t);
5721 args = TREE_PURPOSE (t);
5725 pattern = TREE_TYPE (template);
5726 args = CLASSTYPE_TI_ARGS (type);
5729 /* If the template we're instantiating is incomplete, then clearly
5730 there's nothing we can do. */
5731 if (!COMPLETE_TYPE_P (pattern))
5734 /* If we've recursively instantiated too many templates, stop. */
5735 if (! push_tinst_level (type))
5738 /* Now we're really doing the instantiation. Mark the type as in
5739 the process of being defined. */
5740 TYPE_BEING_DEFINED (type) = 1;
5742 /* We may be in the middle of deferred access check. Disable
5744 push_deferring_access_checks (dk_no_deferred);
5746 push_to_top_level ();
5748 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5750 /* Set the input location to the template definition. This is needed
5751 if tsubsting causes an error. */
5752 typedecl = TYPE_MAIN_DECL (type);
5753 input_location = DECL_SOURCE_LOCATION (typedecl);
5754 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
5756 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5757 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5758 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5759 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5760 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5761 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5762 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5763 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5764 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5765 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5766 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5767 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5768 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5769 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5770 if (ANON_AGGR_TYPE_P (pattern))
5771 SET_ANON_AGGR_TYPE_P (type);
5772 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
5774 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
5775 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
5778 pbinfo = TYPE_BINFO (pattern);
5780 /* We should never instantiate a nested class before its enclosing
5781 class; we need to look up the nested class by name before we can
5782 instantiate it, and that lookup should instantiate the enclosing
5784 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5785 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5786 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
5788 base_list = NULL_TREE;
5789 if (BINFO_N_BASE_BINFOS (pbinfo))
5792 tree context = TYPE_CONTEXT (type);
5796 /* We must enter the scope containing the type, as that is where
5797 the accessibility of types named in dependent bases are
5799 pushed_scope = push_scope (context ? context : global_namespace);
5801 /* Substitute into each of the bases to determine the actual
5803 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
5806 tree access = BINFO_BASE_ACCESS (pbinfo, i);
5808 /* Substitute to figure out the base class. */
5809 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
5810 if (base == error_mark_node)
5813 base_list = tree_cons (access, base, base_list);
5814 if (BINFO_VIRTUAL_P (pbase_binfo))
5815 TREE_TYPE (base_list) = integer_type_node;
5818 /* The list is now in reverse order; correct that. */
5819 base_list = nreverse (base_list);
5822 pop_scope (pushed_scope);
5824 /* Now call xref_basetypes to set up all the base-class
5826 xref_basetypes (type, base_list);
5829 /* Now that our base classes are set up, enter the scope of the
5830 class, so that name lookups into base classes, etc. will work
5831 correctly. This is precisely analogous to what we do in
5832 begin_class_definition when defining an ordinary non-template
5836 /* Now members are processed in the order of declaration. */
5837 for (member = CLASSTYPE_DECL_LIST (pattern);
5838 member; member = TREE_CHAIN (member))
5840 tree t = TREE_VALUE (member);
5842 if (TREE_PURPOSE (member))
5846 /* Build new CLASSTYPE_NESTED_UTDS. */
5849 bool class_template_p;
5851 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
5852 && TYPE_LANG_SPECIFIC (t)
5853 && CLASSTYPE_IS_TEMPLATE (t));
5854 /* If the member is a class template, then -- even after
5855 substitution -- there may be dependent types in the
5856 template argument list for the class. We increment
5857 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5858 that function will assume that no types are dependent
5859 when outside of a template. */
5860 if (class_template_p)
5861 ++processing_template_decl;
5862 newtag = tsubst (t, args, tf_error, NULL_TREE);
5863 if (class_template_p)
5864 --processing_template_decl;
5865 if (newtag == error_mark_node)
5868 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5870 tree name = TYPE_IDENTIFIER (t);
5872 if (class_template_p)
5873 /* Unfortunately, lookup_template_class sets
5874 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5875 instantiation (i.e., for the type of a member
5876 template class nested within a template class.)
5877 This behavior is required for
5878 maybe_process_partial_specialization to work
5879 correctly, but is not accurate in this case;
5880 the TAG is not an instantiation of anything.
5881 (The corresponding TEMPLATE_DECL is an
5882 instantiation, but the TYPE is not.) */
5883 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5885 /* Now, we call pushtag to put this NEWTAG into the scope of
5886 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5887 pushtag calling push_template_decl. We don't have to do
5888 this for enums because it will already have been done in
5891 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5892 pushtag (name, newtag, /*tag_scope=*/ts_current);
5895 else if (TREE_CODE (t) == FUNCTION_DECL
5896 || DECL_FUNCTION_TEMPLATE_P (t))
5898 /* Build new TYPE_METHODS. */
5901 if (TREE_CODE (t) == TEMPLATE_DECL)
5902 ++processing_template_decl;
5903 r = tsubst (t, args, tf_error, NULL_TREE);
5904 if (TREE_CODE (t) == TEMPLATE_DECL)
5905 --processing_template_decl;
5906 set_current_access_from_decl (r);
5907 finish_member_declaration (r);
5911 /* Build new TYPE_FIELDS. */
5913 if (TREE_CODE (t) != CONST_DECL)
5917 /* The the file and line for this declaration, to
5918 assist in error message reporting. Since we
5919 called push_tinst_level above, we don't need to
5921 input_location = DECL_SOURCE_LOCATION (t);
5923 if (TREE_CODE (t) == TEMPLATE_DECL)
5924 ++processing_template_decl;
5925 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
5926 if (TREE_CODE (t) == TEMPLATE_DECL)
5927 --processing_template_decl;
5928 if (TREE_CODE (r) == VAR_DECL)
5932 [t]he initialization (and any associated
5933 side-effects) of a static data member does
5934 not occur unless the static data member is
5935 itself used in a way that requires the
5936 definition of the static data member to
5939 Therefore, we do not substitute into the
5940 initialized for the static data member here. */
5941 finish_static_data_member_decl
5944 /*init_const_expr_p=*/false,
5945 /*asmspec_tree=*/NULL_TREE,
5947 if (DECL_INITIALIZED_IN_CLASS_P (r))
5948 check_static_variable_definition (r, TREE_TYPE (r));
5950 else if (TREE_CODE (r) == FIELD_DECL)
5952 /* Determine whether R has a valid type and can be
5953 completed later. If R is invalid, then it is
5954 replaced by error_mark_node so that it will not be
5955 added to TYPE_FIELDS. */
5956 tree rtype = TREE_TYPE (r);
5957 if (can_complete_type_without_circularity (rtype))
5958 complete_type (rtype);
5960 if (!COMPLETE_TYPE_P (rtype))
5962 cxx_incomplete_type_error (r, rtype);
5963 r = error_mark_node;
5967 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5968 such a thing will already have been added to the field
5969 list by tsubst_enum in finish_member_declaration in the
5970 CLASSTYPE_NESTED_UTDS case above. */
5971 if (!(TREE_CODE (r) == TYPE_DECL
5972 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5973 && DECL_ARTIFICIAL (r)))
5975 set_current_access_from_decl (r);
5976 finish_member_declaration (r);
5983 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5985 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5987 tree friend_type = t;
5988 bool adjust_processing_template_decl = false;
5990 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5992 /* template <class T> friend class C; */
5993 friend_type = tsubst_friend_class (friend_type, args);
5994 adjust_processing_template_decl = true;
5996 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
5998 /* template <class T> friend class C::D; */
5999 friend_type = tsubst (friend_type, args,
6000 tf_warning_or_error, NULL_TREE);
6001 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
6002 friend_type = TREE_TYPE (friend_type);
6003 adjust_processing_template_decl = true;
6005 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
6007 /* This could be either
6011 when dependent_type_p is false or
6013 template <class U> friend class T::C;
6016 friend_type = tsubst (friend_type, args,
6017 tf_warning_or_error, NULL_TREE);
6018 /* Bump processing_template_decl for correct
6019 dependent_type_p calculation. */
6020 ++processing_template_decl;
6021 if (dependent_type_p (friend_type))
6022 adjust_processing_template_decl = true;
6023 --processing_template_decl;
6025 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
6026 && hidden_name_p (TYPE_NAME (friend_type)))
6030 where C hasn't been declared yet. Let's lookup name
6031 from namespace scope directly, bypassing any name that
6032 come from dependent base class. */
6033 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
6035 /* The call to xref_tag_from_type does injection for friend
6037 push_nested_namespace (ns);
6039 xref_tag_from_type (friend_type, NULL_TREE,
6040 /*tag_scope=*/ts_current);
6041 pop_nested_namespace (ns);
6043 else if (uses_template_parms (friend_type))
6044 /* friend class C<T>; */
6045 friend_type = tsubst (friend_type, args,
6046 tf_warning_or_error, NULL_TREE);
6051 where C is already declared or
6053 friend class C<int>;
6055 We don't have to do anything in these cases. */
6057 if (adjust_processing_template_decl)
6058 /* Trick make_friend_class into realizing that the friend
6059 we're adding is a template, not an ordinary class. It's
6060 important that we use make_friend_class since it will
6061 perform some error-checking and output cross-reference
6063 ++processing_template_decl;
6065 if (friend_type != error_mark_node)
6066 make_friend_class (type, friend_type, /*complain=*/false);
6068 if (adjust_processing_template_decl)
6069 --processing_template_decl;
6073 /* Build new DECL_FRIENDLIST. */
6076 /* The the file and line for this declaration, to
6077 assist in error message reporting. Since we
6078 called push_tinst_level above, we don't need to
6080 input_location = DECL_SOURCE_LOCATION (t);
6082 if (TREE_CODE (t) == TEMPLATE_DECL)
6084 ++processing_template_decl;
6085 push_deferring_access_checks (dk_no_check);
6088 r = tsubst_friend_function (t, args);
6089 add_friend (type, r, /*complain=*/false);
6090 if (TREE_CODE (t) == TEMPLATE_DECL)
6092 pop_deferring_access_checks ();
6093 --processing_template_decl;
6099 /* Set the file and line number information to whatever is given for
6100 the class itself. This puts error messages involving generated
6101 implicit functions at a predictable point, and the same point
6102 that would be used for non-template classes. */
6103 input_location = DECL_SOURCE_LOCATION (typedecl);
6105 unreverse_member_declarations (type);
6106 finish_struct_1 (type);
6107 TYPE_BEING_DEFINED (type) = 0;
6109 /* Now that the class is complete, instantiate default arguments for
6110 any member functions. We don't do this earlier because the
6111 default arguments may reference members of the class. */
6112 if (!PRIMARY_TEMPLATE_P (template))
6113 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
6114 if (TREE_CODE (t) == FUNCTION_DECL
6115 /* Implicitly generated member functions will not have template
6116 information; they are not instantiations, but instead are
6117 created "fresh" for each instantiation. */
6118 && DECL_TEMPLATE_INFO (t))
6119 tsubst_default_arguments (t);
6122 pop_from_top_level ();
6123 pop_deferring_access_checks ();
6126 /* The vtable for a template class can be emitted in any translation
6127 unit in which the class is instantiated. When there is no key
6128 method, however, finish_struct_1 will already have added TYPE to
6129 the keyed_classes list. */
6130 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
6131 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
6137 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6143 else if (TYPE_P (t))
6144 r = tsubst (t, args, complain, in_decl);
6147 r = tsubst_expr (t, args, complain, in_decl,
6148 /*integral_constant_expression_p=*/true);
6149 r = fold_non_dependent_expr (r);
6154 /* Substitute ARGS into the vector or list of template arguments T. */
6157 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6159 int len = TREE_VEC_LENGTH (t);
6160 int need_new = 0, i;
6161 tree *elts = (tree *) alloca (len * sizeof (tree));
6163 for (i = 0; i < len; i++)
6165 tree orig_arg = TREE_VEC_ELT (t, i);
6168 if (TREE_CODE (orig_arg) == TREE_VEC)
6169 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
6171 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
6173 if (new_arg == error_mark_node)
6174 return error_mark_node;
6177 if (new_arg != orig_arg)
6184 t = make_tree_vec (len);
6185 for (i = 0; i < len; i++)
6186 TREE_VEC_ELT (t, i) = elts[i];
6191 /* Return the result of substituting ARGS into the template parameters
6192 given by PARMS. If there are m levels of ARGS and m + n levels of
6193 PARMS, then the result will contain n levels of PARMS. For
6194 example, if PARMS is `template <class T> template <class U>
6195 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
6196 result will be `template <int*, double, class V>'. */
6199 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
6204 /* When substituting into a template, we must set
6205 PROCESSING_TEMPLATE_DECL as the template parameters may be
6206 dependent if they are based on one-another, and the dependency
6207 predicates are short-circuit outside of templates. */
6208 ++processing_template_decl;
6210 for (new_parms = &r;
6211 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
6212 new_parms = &(TREE_CHAIN (*new_parms)),
6213 parms = TREE_CHAIN (parms))
6216 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
6219 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
6225 if (parms == error_mark_node)
6228 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
6230 if (tuple == error_mark_node)
6233 default_value = TREE_PURPOSE (tuple);
6234 parm_decl = TREE_VALUE (tuple);
6236 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
6237 if (TREE_CODE (parm_decl) == PARM_DECL
6238 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
6239 parm_decl = error_mark_node;
6240 default_value = tsubst_template_arg (default_value, args,
6241 complain, NULL_TREE);
6243 tuple = build_tree_list (default_value, parm_decl);
6244 TREE_VEC_ELT (new_vec, i) = tuple;
6248 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
6249 - TMPL_ARGS_DEPTH (args)),
6250 new_vec, NULL_TREE);
6253 --processing_template_decl;
6258 /* Substitute the ARGS into the indicated aggregate (or enumeration)
6259 type T. If T is not an aggregate or enumeration type, it is
6260 handled as if by tsubst. IN_DECL is as for tsubst. If
6261 ENTERING_SCOPE is nonzero, T is the context for a template which
6262 we are presently tsubst'ing. Return the substituted value. */
6265 tsubst_aggr_type (tree t,
6267 tsubst_flags_t complain,
6274 switch (TREE_CODE (t))
6277 if (TYPE_PTRMEMFUNC_P (t))
6278 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
6280 /* Else fall through. */
6283 if (TYPE_TEMPLATE_INFO (t))
6288 bool saved_skip_evaluation;
6290 /* In "sizeof(X<I>)" we need to evaluate "I". */
6291 saved_skip_evaluation = skip_evaluation;
6292 skip_evaluation = false;
6294 /* First, determine the context for the type we are looking
6296 context = TYPE_CONTEXT (t);
6298 context = tsubst_aggr_type (context, args, complain,
6299 in_decl, /*entering_scope=*/1);
6301 /* Then, figure out what arguments are appropriate for the
6302 type we are trying to find. For example, given:
6304 template <class T> struct S;
6305 template <class T, class U> void f(T, U) { S<U> su; }
6307 and supposing that we are instantiating f<int, double>,
6308 then our ARGS will be {int, double}, but, when looking up
6309 S we only want {double}. */
6310 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
6312 if (argvec == error_mark_node)
6313 r = error_mark_node;
6316 r = lookup_template_class (t, argvec, in_decl, context,
6317 entering_scope, complain);
6318 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6321 skip_evaluation = saved_skip_evaluation;
6326 /* This is not a template type, so there's nothing to do. */
6330 return tsubst (t, args, complain, in_decl);
6334 /* Substitute into the default argument ARG (a default argument for
6335 FN), which has the indicated TYPE. */
6338 tsubst_default_argument (tree fn, tree type, tree arg)
6340 tree saved_class_ptr = NULL_TREE;
6341 tree saved_class_ref = NULL_TREE;
6343 /* This default argument came from a template. Instantiate the
6344 default argument here, not in tsubst. In the case of
6353 we must be careful to do name lookup in the scope of S<T>,
6354 rather than in the current class. */
6355 push_access_scope (fn);
6356 /* The "this" pointer is not valid in a default argument. */
6359 saved_class_ptr = current_class_ptr;
6360 cp_function_chain->x_current_class_ptr = NULL_TREE;
6361 saved_class_ref = current_class_ref;
6362 cp_function_chain->x_current_class_ref = NULL_TREE;
6365 push_deferring_access_checks(dk_no_deferred);
6366 /* The default argument expression may cause implicitly defined
6367 member functions to be synthesized, which will result in garbage
6368 collection. We must treat this situation as if we were within
6369 the body of function so as to avoid collecting live data on the
6372 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
6373 tf_warning_or_error, NULL_TREE,
6374 /*integral_constant_expression_p=*/false);
6376 pop_deferring_access_checks();
6378 /* Restore the "this" pointer. */
6381 cp_function_chain->x_current_class_ptr = saved_class_ptr;
6382 cp_function_chain->x_current_class_ref = saved_class_ref;
6385 pop_access_scope (fn);
6387 /* Make sure the default argument is reasonable. */
6388 arg = check_default_argument (type, arg);
6393 /* Substitute into all the default arguments for FN. */
6396 tsubst_default_arguments (tree fn)
6401 tmpl_args = DECL_TI_ARGS (fn);
6403 /* If this function is not yet instantiated, we certainly don't need
6404 its default arguments. */
6405 if (uses_template_parms (tmpl_args))
6408 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
6410 arg = TREE_CHAIN (arg))
6411 if (TREE_PURPOSE (arg))
6412 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
6414 TREE_PURPOSE (arg));
6417 /* Substitute the ARGS into the T, which is a _DECL. Return the
6418 result of the substitution. Issue error and warning messages under
6419 control of COMPLAIN. */
6422 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
6424 location_t saved_loc;
6428 /* Set the filename and linenumber to improve error-reporting. */
6429 saved_loc = input_location;
6430 input_location = DECL_SOURCE_LOCATION (t);
6432 switch (TREE_CODE (t))
6436 /* We can get here when processing a member function template,
6437 member class template, and template template parameter of
6438 a template class. */
6439 tree decl = DECL_TEMPLATE_RESULT (t);
6444 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
6446 /* Template template parameter is treated here. */
6447 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6448 if (new_type == error_mark_node)
6449 return error_mark_node;
6452 TREE_CHAIN (r) = NULL_TREE;
6453 TREE_TYPE (r) = new_type;
6454 DECL_TEMPLATE_RESULT (r)
6455 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
6456 DECL_TEMPLATE_PARMS (r)
6457 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6459 TYPE_NAME (new_type) = r;
6463 /* We might already have an instance of this template.
6464 The ARGS are for the surrounding class type, so the
6465 full args contain the tsubst'd args for the context,
6466 plus the innermost args from the template decl. */
6467 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
6468 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
6469 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
6470 /* Because this is a template, the arguments will still be
6471 dependent, even after substitution. If
6472 PROCESSING_TEMPLATE_DECL is not set, the dependency
6473 predicates will short-circuit. */
6474 ++processing_template_decl;
6475 full_args = tsubst_template_args (tmpl_args, args,
6477 --processing_template_decl;
6478 if (full_args == error_mark_node)
6479 return error_mark_node;
6481 /* tsubst_template_args doesn't copy the vector if
6482 nothing changed. But, *something* should have
6484 gcc_assert (full_args != tmpl_args);
6486 spec = retrieve_specialization (t, full_args,
6487 /*class_specializations_p=*/true);
6488 if (spec != NULL_TREE)
6494 /* Make a new template decl. It will be similar to the
6495 original, but will record the current template arguments.
6496 We also create a new function declaration, which is just
6497 like the old one, but points to this new template, rather
6498 than the old one. */
6500 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
6501 TREE_CHAIN (r) = NULL_TREE;
6503 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6505 if (TREE_CODE (decl) == TYPE_DECL)
6508 ++processing_template_decl;
6509 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6510 --processing_template_decl;
6511 if (new_type == error_mark_node)
6512 return error_mark_node;
6514 TREE_TYPE (r) = new_type;
6515 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6516 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6517 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6518 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
6523 ++processing_template_decl;
6524 new_decl = tsubst (decl, args, complain, in_decl);
6525 --processing_template_decl;
6526 if (new_decl == error_mark_node)
6527 return error_mark_node;
6529 DECL_TEMPLATE_RESULT (r) = new_decl;
6530 DECL_TI_TEMPLATE (new_decl) = r;
6531 TREE_TYPE (r) = TREE_TYPE (new_decl);
6532 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6533 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
6536 SET_DECL_IMPLICIT_INSTANTIATION (r);
6537 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6538 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6540 /* The template parameters for this new template are all the
6541 template parameters for the old template, except the
6542 outermost level of parameters. */
6543 DECL_TEMPLATE_PARMS (r)
6544 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6547 if (PRIMARY_TEMPLATE_P (t))
6548 DECL_PRIMARY_TEMPLATE (r) = r;
6550 if (TREE_CODE (decl) != TYPE_DECL)
6551 /* Record this non-type partial instantiation. */
6552 register_specialization (r, t,
6553 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
6561 tree argvec = NULL_TREE;
6569 /* Nobody should be tsubst'ing into non-template functions. */
6570 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
6572 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6577 /* If T is not dependent, just return it. We have to
6578 increment PROCESSING_TEMPLATE_DECL because
6579 value_dependent_expression_p assumes that nothing is
6580 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6581 ++processing_template_decl;
6582 dependent_p = value_dependent_expression_p (t);
6583 --processing_template_decl;
6587 /* Calculate the most general template of which R is a
6588 specialization, and the complete set of arguments used to
6590 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6591 argvec = tsubst_template_args (DECL_TI_ARGS
6592 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6593 args, complain, in_decl);
6595 /* Check to see if we already have this specialization. */
6596 spec = retrieve_specialization (gen_tmpl, argvec,
6597 /*class_specializations_p=*/false);
6605 /* We can see more levels of arguments than parameters if
6606 there was a specialization of a member template, like
6609 template <class T> struct S { template <class U> void f(); }
6610 template <> template <class U> void S<int>::f(U);
6612 Here, we'll be substituting into the specialization,
6613 because that's where we can find the code we actually
6614 want to generate, but we'll have enough arguments for
6615 the most general template.
6617 We also deal with the peculiar case:
6619 template <class T> struct S {
6620 template <class U> friend void f();
6622 template <class U> void f() {}
6624 template void f<double>();
6626 Here, the ARGS for the instantiation of will be {int,
6627 double}. But, we only need as many ARGS as there are
6628 levels of template parameters in CODE_PATTERN. We are
6629 careful not to get fooled into reducing the ARGS in
6632 template <class T> struct S { template <class U> void f(U); }
6633 template <class T> template <> void S<T>::f(int) {}
6635 which we can spot because the pattern will be a
6636 specialization in this case. */
6637 args_depth = TMPL_ARGS_DEPTH (args);
6639 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6640 if (args_depth > parms_depth
6641 && !DECL_TEMPLATE_SPECIALIZATION (t))
6642 args = get_innermost_template_args (args, parms_depth);
6646 /* This special case arises when we have something like this:
6648 template <class T> struct S {
6649 friend void f<int>(int, double);
6652 Here, the DECL_TI_TEMPLATE for the friend declaration
6653 will be an IDENTIFIER_NODE. We are being called from
6654 tsubst_friend_function, and we want only to create a
6655 new decl (R) with appropriate types so that we can call
6656 determine_specialization. */
6657 gen_tmpl = NULL_TREE;
6660 if (DECL_CLASS_SCOPE_P (t))
6662 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6666 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6667 complain, t, /*entering_scope=*/1);
6672 ctx = DECL_CONTEXT (t);
6674 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6675 if (type == error_mark_node)
6676 return error_mark_node;
6678 /* We do NOT check for matching decls pushed separately at this
6679 point, as they may not represent instantiations of this
6680 template, and in any case are considered separate under the
6683 DECL_USE_TEMPLATE (r) = 0;
6684 TREE_TYPE (r) = type;
6685 /* Clear out the mangled name and RTL for the instantiation. */
6686 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6687 SET_DECL_RTL (r, NULL_RTX);
6688 DECL_INITIAL (r) = NULL_TREE;
6689 DECL_CONTEXT (r) = ctx;
6691 if (member && DECL_CONV_FN_P (r))
6692 /* Type-conversion operator. Reconstruct the name, in
6693 case it's the name of one of the template's parameters. */
6694 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6696 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6698 DECL_RESULT (r) = NULL_TREE;
6700 TREE_STATIC (r) = 0;
6701 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6702 DECL_EXTERNAL (r) = 1;
6703 /* If this is an instantiation of a function with internal
6704 linkage, we already know what object file linkage will be
6705 assigned to the instantiation. */
6706 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
6707 DECL_DEFER_OUTPUT (r) = 0;
6708 TREE_CHAIN (r) = NULL_TREE;
6709 DECL_PENDING_INLINE_INFO (r) = 0;
6710 DECL_PENDING_INLINE_P (r) = 0;
6711 DECL_SAVED_TREE (r) = NULL_TREE;
6713 if (DECL_CLONED_FUNCTION (r))
6715 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6717 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6718 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6721 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6722 this in the special friend case mentioned above where
6723 GEN_TMPL is NULL. */
6726 DECL_TEMPLATE_INFO (r)
6727 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6728 SET_DECL_IMPLICIT_INSTANTIATION (r);
6729 register_specialization (r, gen_tmpl, argvec, false);
6731 /* We're not supposed to instantiate default arguments
6732 until they are called, for a template. But, for a
6735 template <class T> void f ()
6736 { extern void g(int i = T()); }
6738 we should do the substitution when the template is
6739 instantiated. We handle the member function case in
6740 instantiate_class_template since the default arguments
6741 might refer to other members of the class. */
6743 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6744 && !uses_template_parms (argvec))
6745 tsubst_default_arguments (r);
6748 DECL_TEMPLATE_INFO (r) = NULL_TREE;
6750 /* Copy the list of befriending classes. */
6751 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6753 friends = &TREE_CHAIN (*friends))
6755 *friends = copy_node (*friends);
6756 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6761 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6763 maybe_retrofit_in_chrg (r);
6764 if (DECL_CONSTRUCTOR_P (r))
6765 grok_ctor_properties (ctx, r);
6766 /* If this is an instantiation of a member template, clone it.
6767 If it isn't, that'll be handled by
6768 clone_constructors_and_destructors. */
6769 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6770 clone_function_decl (r, /*update_method_vec_p=*/0);
6772 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
6773 && !grok_op_properties (r, (complain & tf_error) != 0))
6774 return error_mark_node;
6776 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6777 SET_DECL_FRIEND_CONTEXT (r,
6778 tsubst (DECL_FRIEND_CONTEXT (t),
6779 args, complain, in_decl));
6781 /* Possibly limit visibility based on template args. */
6782 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
6783 if (DECL_VISIBILITY_SPECIFIED (t))
6785 DECL_VISIBILITY_SPECIFIED (r) = 0;
6787 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
6789 determine_visibility (r);
6798 if (DECL_TEMPLATE_PARM_P (t))
6799 SET_DECL_TEMPLATE_PARM_P (r);
6801 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6802 type = type_decays_to (type);
6803 TREE_TYPE (r) = type;
6804 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6806 if (DECL_INITIAL (r))
6808 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6809 DECL_INITIAL (r) = TREE_TYPE (r);
6811 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6815 DECL_CONTEXT (r) = NULL_TREE;
6817 if (!DECL_TEMPLATE_PARM_P (r))
6818 DECL_ARG_TYPE (r) = type_passed_as (type);
6820 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6821 complain, TREE_CHAIN (t));
6830 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6831 if (type == error_mark_node)
6832 return error_mark_node;
6833 TREE_TYPE (r) = type;
6834 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6836 /* DECL_INITIAL gives the number of bits in a bit-field. */
6838 = tsubst_expr (DECL_INITIAL (t), args,
6840 /*integral_constant_expression_p=*/true);
6841 /* We don't have to set DECL_CONTEXT here; it is set by
6842 finish_member_declaration. */
6843 TREE_CHAIN (r) = NULL_TREE;
6844 if (VOID_TYPE_P (type))
6845 error ("instantiation of %q+D as type %qT", r, type);
6850 /* We reach here only for member using decls. */
6851 if (DECL_DEPENDENT_P (t))
6853 r = do_class_using_decl
6854 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
6855 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
6857 r = error_mark_node;
6862 TREE_CHAIN (r) = NULL_TREE;
6869 tree argvec = NULL_TREE;
6870 tree gen_tmpl = NULL_TREE;
6872 tree tmpl = NULL_TREE;
6874 tree type = NULL_TREE;
6877 if (TREE_CODE (t) == TYPE_DECL)
6879 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6880 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6881 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6883 /* If this is the canonical decl, we don't have to
6884 mess with instantiations, and often we can't (for
6885 typename, template type parms and such). Note that
6886 TYPE_NAME is not correct for the above test if
6887 we've copied the type for a typedef. */
6888 r = TYPE_NAME (type);
6893 /* Check to see if we already have the specialization we
6896 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
6898 /* T is a static data member or namespace-scope entity.
6899 We have to substitute into namespace-scope variables
6900 (even though such entities are never templates) because
6903 template <class T> void f() { extern T t; }
6905 where the entity referenced is not known until
6906 instantiation time. */
6908 ctx = DECL_CONTEXT (t);
6909 if (DECL_CLASS_SCOPE_P (t))
6911 ctx = tsubst_aggr_type (ctx, args,
6913 in_decl, /*entering_scope=*/1);
6914 /* If CTX is unchanged, then T is in fact the
6915 specialization we want. That situation occurs when
6916 referencing a static data member within in its own
6917 class. We can use pointer equality, rather than
6918 same_type_p, because DECL_CONTEXT is always
6920 if (ctx == DECL_CONTEXT (t))
6926 tmpl = DECL_TI_TEMPLATE (t);
6927 gen_tmpl = most_general_template (tmpl);
6928 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6929 spec = (retrieve_specialization
6931 /*class_specializations_p=*/false));
6936 /* A local variable. */
6938 /* Subsequent calls to pushdecl will fill this in. */
6940 spec = retrieve_local_specialization (t);
6942 /* If we already have the specialization we need, there is
6943 nothing more to do. */
6950 /* Create a new node for the specialization we need. */
6952 if (TREE_CODE (r) == VAR_DECL)
6954 /* Even if the original location is out of scope, the
6955 newly substituted one is not. */
6956 DECL_DEAD_FOR_LOCAL (r) = 0;
6957 DECL_INITIALIZED_P (r) = 0;
6958 DECL_TEMPLATE_INSTANTIATED (r) = 0;
6959 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6960 if (type == error_mark_node)
6961 return error_mark_node;
6962 if (TREE_CODE (type) == FUNCTION_TYPE)
6964 /* It may seem that this case cannot occur, since:
6969 declares a function, not a variable. However:
6972 template <typename T> void g() { T t; }
6973 template void g<f>();
6975 is an attempt to declare a variable with function
6977 error ("variable %qD has function type",
6978 /* R is not yet sufficiently initialized, so we
6979 just use its name. */
6981 return error_mark_node;
6983 type = complete_type (type);
6984 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6985 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6986 type = check_var_type (DECL_NAME (r), type);
6988 if (DECL_HAS_VALUE_EXPR_P (t))
6990 tree ve = DECL_VALUE_EXPR (t);
6991 ve = tsubst_expr (ve, args, complain, in_decl,
6992 /*constant_expression_p=*/false);
6993 SET_DECL_VALUE_EXPR (r, ve);
6996 else if (DECL_SELF_REFERENCE_P (t))
6997 SET_DECL_SELF_REFERENCE_P (r);
6998 TREE_TYPE (r) = type;
6999 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
7000 DECL_CONTEXT (r) = ctx;
7001 /* Clear out the mangled name and RTL for the instantiation. */
7002 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
7003 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
7004 SET_DECL_RTL (r, NULL_RTX);
7005 /* The initializer must not be expanded until it is required;
7007 DECL_INITIAL (r) = NULL_TREE;
7008 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
7009 SET_DECL_RTL (r, NULL_RTX);
7010 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
7011 if (TREE_CODE (r) == VAR_DECL)
7013 /* Possibly limit visibility based on template args. */
7014 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
7015 if (DECL_VISIBILITY_SPECIFIED (t))
7017 DECL_VISIBILITY_SPECIFIED (r) = 0;
7019 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
7021 determine_visibility (r);
7026 /* A static data member declaration is always marked
7027 external when it is declared in-class, even if an
7028 initializer is present. We mimic the non-template
7030 DECL_EXTERNAL (r) = 1;
7032 register_specialization (r, gen_tmpl, argvec, false);
7033 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
7034 SET_DECL_IMPLICIT_INSTANTIATION (r);
7037 register_local_specialization (r, t);
7039 TREE_CHAIN (r) = NULL_TREE;
7048 /* Restore the file and line information. */
7049 input_location = saved_loc;
7054 /* Substitute into the ARG_TYPES of a function type. */
7057 tsubst_arg_types (tree arg_types,
7059 tsubst_flags_t complain,
7062 tree remaining_arg_types;
7065 tree result = NULL_TREE;
7067 if (!arg_types || arg_types == void_list_node)
7070 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
7071 args, complain, in_decl);
7072 if (remaining_arg_types == error_mark_node)
7073 return error_mark_node;
7075 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
7076 if (type == error_mark_node)
7077 return error_mark_node;
7078 if (VOID_TYPE_P (type))
7080 if (complain & tf_error)
7082 error ("invalid parameter type %qT", type);
7084 error ("in declaration %q+D", in_decl);
7086 return error_mark_node;
7089 /* Do array-to-pointer, function-to-pointer conversion, and ignore
7090 top-level qualifiers as required. */
7091 type = TYPE_MAIN_VARIANT (type_decays_to (type));
7093 /* We do not substitute into default arguments here. The standard
7094 mandates that they be instantiated only when needed, which is
7095 done in build_over_call. */
7096 default_arg = TREE_PURPOSE (arg_types);
7098 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
7100 /* We've instantiated a template before its default arguments
7101 have been parsed. This can happen for a nested template
7102 class, and is not an error unless we require the default
7103 argument in a call of this function. */
7104 result = tree_cons (default_arg, type, remaining_arg_types);
7105 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result);
7108 result = hash_tree_cons (default_arg, type, remaining_arg_types);
7113 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
7114 *not* handle the exception-specification for FNTYPE, because the
7115 initial substitution of explicitly provided template parameters
7116 during argument deduction forbids substitution into the
7117 exception-specification:
7121 All references in the function type of the function template to the
7122 corresponding template parameters are replaced by the specified tem-
7123 plate argument values. If a substitution in a template parameter or
7124 in the function type of the function template results in an invalid
7125 type, type deduction fails. [Note: The equivalent substitution in
7126 exception specifications is done only when the function is instanti-
7127 ated, at which point a program is ill-formed if the substitution
7128 results in an invalid type.] */
7131 tsubst_function_type (tree t,
7133 tsubst_flags_t complain,
7140 /* The TYPE_CONTEXT is not used for function/method types. */
7141 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
7143 /* Substitute the return type. */
7144 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7145 if (return_type == error_mark_node)
7146 return error_mark_node;
7147 /* The standard does not presently indicate that creation of a
7148 function type with an invalid return type is a deduction failure.
7149 However, that is clearly analogous to creating an array of "void"
7150 or a reference to a reference. This is core issue #486. */
7151 if (TREE_CODE (return_type) == ARRAY_TYPE
7152 || TREE_CODE (return_type) == FUNCTION_TYPE)
7154 if (complain & tf_error)
7156 if (TREE_CODE (return_type) == ARRAY_TYPE)
7157 error ("function returning an array");
7159 error ("function returning a function");
7161 return error_mark_node;
7164 /* Substitute the argument types. */
7165 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
7167 if (arg_types == error_mark_node)
7168 return error_mark_node;
7170 /* Construct a new type node and return it. */
7171 if (TREE_CODE (t) == FUNCTION_TYPE)
7172 fntype = build_function_type (return_type, arg_types);
7175 tree r = TREE_TYPE (TREE_VALUE (arg_types));
7176 if (! IS_AGGR_TYPE (r))
7180 Type deduction may fail for any of the following
7183 -- Attempting to create "pointer to member of T" when T
7184 is not a class type. */
7185 if (complain & tf_error)
7186 error ("creating pointer to member function of non-class type %qT",
7188 return error_mark_node;
7191 fntype = build_method_type_directly (r, return_type,
7192 TREE_CHAIN (arg_types));
7194 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
7195 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
7200 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
7201 ARGS into that specification, and return the substituted
7202 specification. If there is no specification, return NULL_TREE. */
7205 tsubst_exception_specification (tree fntype,
7207 tsubst_flags_t complain,
7213 specs = TYPE_RAISES_EXCEPTIONS (fntype);
7214 new_specs = NULL_TREE;
7217 if (! TREE_VALUE (specs))
7223 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
7224 if (spec == error_mark_node)
7226 new_specs = add_exception_specifier (new_specs, spec, complain);
7227 specs = TREE_CHAIN (specs);
7233 /* Take the tree structure T and replace template parameters used
7234 therein with the argument vector ARGS. IN_DECL is an associated
7235 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
7236 Issue error and warning messages under control of COMPLAIN. Note
7237 that we must be relatively non-tolerant of extensions here, in
7238 order to preserve conformance; if we allow substitutions that
7239 should not be allowed, we may allow argument deductions that should
7240 not succeed, and therefore report ambiguous overload situations
7241 where there are none. In theory, we could allow the substitution,
7242 but indicate that it should have failed, and allow our caller to
7243 make sure that the right thing happens, but we don't try to do this
7246 This function is used for dealing with types, decls and the like;
7247 for expressions, use tsubst_expr or tsubst_copy. */
7250 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7254 if (t == NULL_TREE || t == error_mark_node
7255 || t == integer_type_node
7256 || t == void_type_node
7257 || t == char_type_node
7258 || t == unknown_type_node
7259 || TREE_CODE (t) == NAMESPACE_DECL)
7263 return tsubst_decl (t, args, complain);
7265 if (TREE_CODE (t) == IDENTIFIER_NODE)
7266 type = IDENTIFIER_TYPE_VALUE (t);
7268 type = TREE_TYPE (t);
7270 gcc_assert (type != unknown_type_node);
7273 && TREE_CODE (t) != TYPENAME_TYPE
7274 && TREE_CODE (t) != IDENTIFIER_NODE
7275 && TREE_CODE (t) != FUNCTION_TYPE
7276 && TREE_CODE (t) != METHOD_TYPE)
7277 type = tsubst (type, args, complain, in_decl);
7278 if (type == error_mark_node)
7279 return error_mark_node;
7281 switch (TREE_CODE (t))
7286 return tsubst_aggr_type (t, args, complain, in_decl,
7287 /*entering_scope=*/0);
7290 case IDENTIFIER_NODE:
7302 if (t == integer_type_node)
7305 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
7306 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
7310 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
7312 max = tsubst_expr (omax, args, complain, in_decl,
7313 /*integral_constant_expression_p=*/false);
7314 max = fold_decl_constant_value (max);
7316 if (TREE_CODE (max) != INTEGER_CST
7317 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
7318 && !at_function_scope_p ())
7320 if (complain & tf_error)
7321 error ("array bound is not an integer constant");
7322 return error_mark_node;
7327 Type deduction may fail for any of the following
7330 Attempting to create an array with a size that is
7331 zero or negative. */
7332 if (integer_zerop (max) && !(complain & tf_error))
7333 /* We must fail if performing argument deduction (as
7334 indicated by the state of complain), so that
7335 another substitution can be found. */
7336 return error_mark_node;
7337 else if (TREE_CODE (max) == INTEGER_CST
7338 && INT_CST_LT (max, integer_zero_node))
7340 if (complain & tf_error)
7341 error ("creating array with negative size (%qE)", max);
7343 return error_mark_node;
7346 return compute_array_index_type (NULL_TREE, max);
7349 case TEMPLATE_TYPE_PARM:
7350 case TEMPLATE_TEMPLATE_PARM:
7351 case BOUND_TEMPLATE_TEMPLATE_PARM:
7352 case TEMPLATE_PARM_INDEX:
7357 tree arg = NULL_TREE;
7361 gcc_assert (TREE_VEC_LENGTH (args) > 0);
7362 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7363 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
7364 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7366 idx = TEMPLATE_TYPE_IDX (t);
7367 level = TEMPLATE_TYPE_LEVEL (t);
7371 idx = TEMPLATE_PARM_IDX (t);
7372 level = TEMPLATE_PARM_LEVEL (t);
7375 levels = TMPL_ARGS_DEPTH (args);
7376 if (level <= levels)
7377 arg = TMPL_ARG (args, level, idx);
7379 if (arg == error_mark_node)
7380 return error_mark_node;
7381 else if (arg != NULL_TREE)
7383 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
7386 gcc_assert (TYPE_P (arg));
7388 /* cv-quals from the template are discarded when
7389 substituting in a function or reference type. */
7390 if (TREE_CODE (arg) == FUNCTION_TYPE
7391 || TREE_CODE (arg) == METHOD_TYPE
7392 || TREE_CODE (arg) == REFERENCE_TYPE)
7393 quals = cp_type_quals (arg);
7395 quals = cp_type_quals (arg) | cp_type_quals (t);
7397 return cp_build_qualified_type_real
7398 (arg, quals, complain | tf_ignore_bad_quals);
7400 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7402 /* We are processing a type constructed from a
7403 template template parameter. */
7404 tree argvec = tsubst (TYPE_TI_ARGS (t),
7405 args, complain, in_decl);
7406 if (argvec == error_mark_node)
7407 return error_mark_node;
7409 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
7410 are resolving nested-types in the signature of a
7411 member function templates. Otherwise ARG is a
7412 TEMPLATE_DECL and is the real template to be
7414 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
7415 arg = TYPE_NAME (arg);
7417 r = lookup_template_class (arg,
7420 /*entering_scope=*/0,
7422 return cp_build_qualified_type_real
7423 (r, TYPE_QUALS (t), complain);
7426 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
7431 /* This can happen during the attempted tsubst'ing in
7432 unify. This means that we don't yet have any information
7433 about the template parameter in question. */
7436 /* If we get here, we must have been looking at a parm for a
7437 more deeply nested template. Make a new version of this
7438 template parameter, but with a lower level. */
7439 switch (TREE_CODE (t))
7441 case TEMPLATE_TYPE_PARM:
7442 case TEMPLATE_TEMPLATE_PARM:
7443 case BOUND_TEMPLATE_TEMPLATE_PARM:
7444 if (cp_type_quals (t))
7446 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
7447 r = cp_build_qualified_type_real
7448 (r, cp_type_quals (t),
7449 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7450 ? tf_ignore_bad_quals : 0));
7455 TEMPLATE_TYPE_PARM_INDEX (r)
7456 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
7458 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
7459 TYPE_MAIN_VARIANT (r) = r;
7460 TYPE_POINTER_TO (r) = NULL_TREE;
7461 TYPE_REFERENCE_TO (r) = NULL_TREE;
7463 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7465 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
7467 if (argvec == error_mark_node)
7468 return error_mark_node;
7470 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
7471 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
7476 case TEMPLATE_PARM_INDEX:
7477 r = reduce_template_parm_level (t, type, levels);
7489 tree purpose, value, chain;
7491 if (t == void_list_node)
7494 purpose = TREE_PURPOSE (t);
7497 purpose = tsubst (purpose, args, complain, in_decl);
7498 if (purpose == error_mark_node)
7499 return error_mark_node;
7501 value = TREE_VALUE (t);
7504 value = tsubst (value, args, complain, in_decl);
7505 if (value == error_mark_node)
7506 return error_mark_node;
7508 chain = TREE_CHAIN (t);
7509 if (chain && chain != void_type_node)
7511 chain = tsubst (chain, args, complain, in_decl);
7512 if (chain == error_mark_node)
7513 return error_mark_node;
7515 if (purpose == TREE_PURPOSE (t)
7516 && value == TREE_VALUE (t)
7517 && chain == TREE_CHAIN (t))
7519 return hash_tree_cons (purpose, value, chain);
7523 /* We should never be tsubsting a binfo. */
7527 /* A vector of template arguments. */
7529 return tsubst_template_args (t, args, complain, in_decl);
7532 case REFERENCE_TYPE:
7534 enum tree_code code;
7536 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
7539 code = TREE_CODE (t);
7544 Type deduction may fail for any of the following
7547 -- Attempting to create a pointer to reference type.
7548 -- Attempting to create a reference to a reference type or
7549 a reference to void. */
7550 if (TREE_CODE (type) == REFERENCE_TYPE
7551 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
7553 static location_t last_loc;
7555 /* We keep track of the last time we issued this error
7556 message to avoid spewing a ton of messages during a
7557 single bad template instantiation. */
7558 if (complain & tf_error
7559 #ifdef USE_MAPPED_LOCATION
7560 && last_loc != input_location
7562 && (last_loc.line != input_line
7563 || last_loc.file != input_filename)
7567 if (TREE_CODE (type) == VOID_TYPE)
7568 error ("forming reference to void");
7570 error ("forming %s to reference type %qT",
7571 (code == POINTER_TYPE) ? "pointer" : "reference",
7573 last_loc = input_location;
7576 return error_mark_node;
7578 else if (code == POINTER_TYPE)
7580 r = build_pointer_type (type);
7581 if (TREE_CODE (type) == METHOD_TYPE)
7582 r = build_ptrmemfunc_type (r);
7585 r = build_reference_type (type);
7586 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7588 if (r != error_mark_node)
7589 /* Will this ever be needed for TYPE_..._TO values? */
7596 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7597 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7601 Type deduction may fail for any of the following
7604 -- Attempting to create "pointer to member of T" when T
7605 is not a class type. */
7606 if (complain & tf_error)
7607 error ("creating pointer to member of non-class type %qT", r);
7608 return error_mark_node;
7610 if (TREE_CODE (type) == REFERENCE_TYPE)
7612 if (complain & tf_error)
7613 error ("creating pointer to member reference type %qT", type);
7614 return error_mark_node;
7616 if (TREE_CODE (type) == VOID_TYPE)
7618 if (complain & tf_error)
7619 error ("creating pointer to member of type void");
7620 return error_mark_node;
7622 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
7623 if (TREE_CODE (type) == FUNCTION_TYPE)
7625 /* The type of the implicit object parameter gets its
7626 cv-qualifiers from the FUNCTION_TYPE. */
7628 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
7629 cp_type_quals (type));
7631 method_type = build_method_type_directly (this_type,
7633 TYPE_ARG_TYPES (type));
7634 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
7635 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
7639 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7648 fntype = tsubst_function_type (t, args, complain, in_decl);
7649 if (fntype == error_mark_node)
7650 return error_mark_node;
7652 /* Substitute the exception specification. */
7653 specs = tsubst_exception_specification (t, args, complain,
7655 if (specs == error_mark_node)
7656 return error_mark_node;
7658 fntype = build_exception_variant (fntype, specs);
7663 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7664 if (domain == error_mark_node)
7665 return error_mark_node;
7667 /* As an optimization, we avoid regenerating the array type if
7668 it will obviously be the same as T. */
7669 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7672 /* These checks should match the ones in grokdeclarator.
7676 The deduction may fail for any of the following reasons:
7678 -- Attempting to create an array with an element type that
7679 is void, a function type, or a reference type, or [DR337]
7680 an abstract class type. */
7681 if (TREE_CODE (type) == VOID_TYPE
7682 || TREE_CODE (type) == FUNCTION_TYPE
7683 || TREE_CODE (type) == REFERENCE_TYPE)
7685 if (complain & tf_error)
7686 error ("creating array of %qT", type);
7687 return error_mark_node;
7689 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7691 if (complain & tf_error)
7692 error ("creating array of %qT, which is an abstract class type",
7694 return error_mark_node;
7697 r = build_cplus_array_type (type, domain);
7704 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7705 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7707 if (e1 == error_mark_node || e2 == error_mark_node)
7708 return error_mark_node;
7710 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
7716 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7717 if (e == error_mark_node)
7718 return error_mark_node;
7720 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
7725 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7726 in_decl, /*entering_scope=*/1);
7727 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7730 if (ctx == error_mark_node || f == error_mark_node)
7731 return error_mark_node;
7733 if (!IS_AGGR_TYPE (ctx))
7735 if (complain & tf_error)
7736 error ("%qT is not a class, struct, or union type", ctx);
7737 return error_mark_node;
7739 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7741 /* Normally, make_typename_type does not require that the CTX
7742 have complete type in order to allow things like:
7744 template <class T> struct S { typename S<T>::X Y; };
7746 But, such constructs have already been resolved by this
7747 point, so here CTX really should have complete type, unless
7748 it's a partial instantiation. */
7749 ctx = complete_type (ctx);
7750 if (!COMPLETE_TYPE_P (ctx))
7752 if (complain & tf_error)
7753 cxx_incomplete_type_error (NULL_TREE, ctx);
7754 return error_mark_node;
7758 f = make_typename_type (ctx, f, typename_type,
7759 (complain & tf_error) | tf_keep_type_decl);
7760 if (f == error_mark_node)
7762 if (TREE_CODE (f) == TYPE_DECL)
7764 complain |= tf_ignore_bad_quals;
7768 if (TREE_CODE (f) != TYPENAME_TYPE)
7770 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
7771 error ("%qT resolves to %qT, which is not an enumeration type",
7773 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
7774 error ("%qT resolves to %qT, which is is not a class type",
7778 return cp_build_qualified_type_real
7779 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7782 case UNBOUND_CLASS_TEMPLATE:
7784 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7785 in_decl, /*entering_scope=*/1);
7786 tree name = TYPE_IDENTIFIER (t);
7787 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
7789 if (ctx == error_mark_node || name == error_mark_node)
7790 return error_mark_node;
7793 parm_list = tsubst_template_parms (parm_list, args, complain);
7794 return make_unbound_class_template (ctx, name, parm_list, complain);
7804 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7805 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
7806 /*integral_constant_expression_p=*/false);
7807 if (e1 == error_mark_node || e2 == error_mark_node)
7808 return error_mark_node;
7810 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
7815 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7816 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7817 if (e1 == error_mark_node || e2 == error_mark_node)
7818 return error_mark_node;
7820 return build_qualified_name (/*type=*/NULL_TREE,
7821 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
7828 type = finish_typeof (tsubst_expr
7829 (TYPEOF_TYPE_EXPR (t), args,
7831 /*integral_constant_expression_p=*/false));
7832 return cp_build_qualified_type_real (type,
7834 | cp_type_quals (type),
7839 sorry ("use of %qs in template",
7840 tree_code_name [(int) TREE_CODE (t)]);
7841 return error_mark_node;
7845 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7846 type of the expression on the left-hand side of the "." or "->"
7850 tsubst_baselink (tree baselink, tree object_type,
7851 tree args, tsubst_flags_t complain, tree in_decl)
7854 tree qualifying_scope;
7857 tree template_args = 0;
7858 bool template_id_p = false;
7860 /* A baselink indicates a function from a base class. Both the
7861 BASELINK_ACCESS_BINFO and the base class referenced may
7862 indicate bases of the template class, rather than the
7863 instantiated class. In addition, lookups that were not
7864 ambiguous before may be ambiguous now. Therefore, we perform
7865 the lookup again. */
7866 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7867 qualifying_scope = tsubst (qualifying_scope, args,
7869 fns = BASELINK_FUNCTIONS (baselink);
7870 optype = BASELINK_OPTYPE (baselink);
7871 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7873 template_id_p = true;
7874 template_args = TREE_OPERAND (fns, 1);
7875 fns = TREE_OPERAND (fns, 0);
7877 template_args = tsubst_template_args (template_args, args,
7880 name = DECL_NAME (get_first_fn (fns));
7881 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7883 /* If lookup found a single function, mark it as used at this
7884 point. (If it lookup found multiple functions the one selected
7885 later by overload resolution will be marked as used at that
7887 if (BASELINK_P (baselink))
7888 fns = BASELINK_FUNCTIONS (baselink);
7889 if (!template_id_p && !really_overloaded_fn (fns))
7890 mark_used (OVL_CURRENT (fns));
7892 /* Add back the template arguments, if present. */
7893 if (BASELINK_P (baselink) && template_id_p)
7894 BASELINK_FUNCTIONS (baselink)
7895 = build_nt (TEMPLATE_ID_EXPR,
7896 BASELINK_FUNCTIONS (baselink),
7898 /* Update the conversion operator type. */
7899 BASELINK_OPTYPE (baselink)
7900 = tsubst (optype, args, complain, in_decl);
7903 object_type = current_class_type;
7904 return adjust_result_of_qualified_name_lookup (baselink,
7909 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7910 true if the qualified-id will be a postfix-expression in-and-of
7911 itself; false if more of the postfix-expression follows the
7912 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7916 tsubst_qualified_id (tree qualified_id, tree args,
7917 tsubst_flags_t complain, tree in_decl,
7918 bool done, bool address_p)
7926 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
7928 /* Figure out what name to look up. */
7929 name = TREE_OPERAND (qualified_id, 1);
7930 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7933 template_args = TREE_OPERAND (name, 1);
7935 template_args = tsubst_template_args (template_args, args,
7937 name = TREE_OPERAND (name, 0);
7941 is_template = false;
7942 template_args = NULL_TREE;
7945 /* Substitute into the qualifying scope. When there are no ARGS, we
7946 are just trying to simplify a non-dependent expression. In that
7947 case the qualifying scope may be dependent, and, in any case,
7948 substituting will not help. */
7949 scope = TREE_OPERAND (qualified_id, 0);
7952 scope = tsubst (scope, args, complain, in_decl);
7953 expr = tsubst_copy (name, args, complain, in_decl);
7958 if (dependent_type_p (scope))
7959 return build_qualified_name (/*type=*/NULL_TREE,
7961 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
7963 if (!BASELINK_P (name) && !DECL_P (expr))
7965 if (TREE_CODE (expr) == BIT_NOT_EXPR)
7966 /* If this were actually a destructor call, it would have been
7967 parsed as such by the parser. */
7968 expr = error_mark_node;
7970 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7971 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7972 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7974 if (complain & tf_error)
7976 error ("dependent-name %qE is parsed as a non-type, but "
7977 "instantiation yields a type", qualified_id);
7978 inform ("say %<typename %E%> if a type is meant", qualified_id);
7980 return error_mark_node;
7986 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7988 /* Remember that there was a reference to this entity. */
7992 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
7994 if (complain & tf_error)
7995 qualified_name_lookup_error (scope,
7996 TREE_OPERAND (qualified_id, 1),
7998 return error_mark_node;
8002 expr = lookup_template_function (expr, template_args);
8004 if (expr == error_mark_node && complain & tf_error)
8005 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
8007 else if (TYPE_P (scope))
8009 expr = (adjust_result_of_qualified_name_lookup
8010 (expr, scope, current_class_type));
8011 expr = (finish_qualified_id_expr
8012 (scope, expr, done, address_p,
8013 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
8014 /*template_arg_p=*/false));
8017 /* Expressions do not generally have reference type. */
8018 if (TREE_CODE (expr) != SCOPE_REF
8019 /* However, if we're about to form a pointer-to-member, we just
8020 want the referenced member referenced. */
8021 && TREE_CODE (expr) != OFFSET_REF)
8022 expr = convert_from_reference (expr);
8027 /* Like tsubst, but deals with expressions. This function just replaces
8028 template parms; to finish processing the resultant expression, use
8032 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8034 enum tree_code code;
8037 if (t == NULL_TREE || t == error_mark_node)
8040 code = TREE_CODE (t);
8045 r = retrieve_local_specialization (t);
8046 gcc_assert (r != NULL);
8055 if (DECL_TEMPLATE_PARM_P (t))
8056 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
8057 /* There is no need to substitute into namespace-scope
8059 if (DECL_NAMESPACE_SCOPE_P (t))
8061 /* If ARGS is NULL, then T is known to be non-dependent. */
8062 if (args == NULL_TREE)
8063 return integral_constant_value (t);
8065 /* Unfortunately, we cannot just call lookup_name here.
8068 template <int I> int f() {
8070 struct S { void g() { E e = a; } };
8073 When we instantiate f<7>::S::g(), say, lookup_name is not
8074 clever enough to find f<7>::a. */
8076 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
8077 /*entering_scope=*/0);
8079 for (v = TYPE_VALUES (enum_type);
8082 if (TREE_PURPOSE (v) == DECL_NAME (t))
8083 return TREE_VALUE (v);
8085 /* We didn't find the name. That should never happen; if
8086 name-lookup found it during preliminary parsing, we
8087 should find it again here during instantiation. */
8093 if (DECL_CONTEXT (t))
8097 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
8098 /*entering_scope=*/1);
8099 if (ctx != DECL_CONTEXT (t))
8101 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
8104 if (complain & tf_error)
8105 error ("using invalid field %qD", t);
8106 return error_mark_node;
8116 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
8117 || local_variable_p (t))
8118 t = tsubst (t, args, complain, in_decl);
8123 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
8126 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8127 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
8128 args, complain, in_decl);
8129 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
8130 return tsubst (t, args, complain, in_decl);
8131 else if (DECL_CLASS_SCOPE_P (t)
8132 && uses_template_parms (DECL_CONTEXT (t)))
8134 /* Template template argument like the following example need
8137 template <template <class> class TT> struct C {};
8138 template <class T> struct D {
8139 template <class U> struct E {};
8144 We are processing the template argument `E' in #1 for
8145 the template instantiation #2. Originally, `E' is a
8146 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
8147 have to substitute this with one having context `D<int>'. */
8149 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
8150 return lookup_field (context, DECL_NAME(t), 0, false);
8153 /* Ordinary template template argument. */
8157 case REINTERPRET_CAST_EXPR:
8158 case CONST_CAST_EXPR:
8159 case STATIC_CAST_EXPR:
8160 case DYNAMIC_CAST_EXPR:
8163 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8164 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8168 case TRUTH_NOT_EXPR:
8171 case UNARY_PLUS_EXPR: /* Unary + */
8180 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8181 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8188 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
8189 name = TREE_OPERAND (t, 1);
8190 if (TREE_CODE (name) == BIT_NOT_EXPR)
8192 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8194 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8196 else if (TREE_CODE (name) == SCOPE_REF
8197 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
8199 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
8201 name = TREE_OPERAND (name, 1);
8202 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8204 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8205 name = build_qualified_name (/*type=*/NULL_TREE,
8207 /*template_p=*/false);
8209 else if (TREE_CODE (name) == BASELINK)
8210 name = tsubst_baselink (name,
8211 non_reference (TREE_TYPE (object)),
8215 name = tsubst_copy (name, args, complain, in_decl);
8216 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
8222 case TRUNC_DIV_EXPR:
8224 case FLOOR_DIV_EXPR:
8225 case ROUND_DIV_EXPR:
8226 case EXACT_DIV_EXPR:
8230 case TRUNC_MOD_EXPR:
8231 case FLOOR_MOD_EXPR:
8232 case TRUTH_ANDIF_EXPR:
8233 case TRUTH_ORIF_EXPR:
8234 case TRUTH_AND_EXPR:
8251 case PREDECREMENT_EXPR:
8252 case PREINCREMENT_EXPR:
8253 case POSTDECREMENT_EXPR:
8254 case POSTINCREMENT_EXPR:
8256 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8257 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8260 return build_qualified_name (/*type=*/NULL_TREE,
8261 tsubst_copy (TREE_OPERAND (t, 0),
8262 args, complain, in_decl),
8263 tsubst_copy (TREE_OPERAND (t, 1),
8264 args, complain, in_decl),
8265 QUALIFIED_NAME_IS_TEMPLATE (t));
8270 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8271 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8272 NULL_TREE, NULL_TREE);
8275 return build_nt (code,
8276 tsubst_copy (TREE_OPERAND (t, 0), args,
8278 tsubst_copy (TREE_OPERAND (t, 1), args, complain,
8284 case PSEUDO_DTOR_EXPR:
8287 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8288 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8289 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8290 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
8297 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8298 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8299 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8300 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
8307 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8308 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8309 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
8310 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
8314 case TEMPLATE_ID_EXPR:
8316 /* Substituted template arguments */
8317 tree fn = TREE_OPERAND (t, 0);
8318 tree targs = TREE_OPERAND (t, 1);
8320 fn = tsubst_copy (fn, args, complain, in_decl);
8322 targs = tsubst_template_args (targs, args, complain, in_decl);
8324 return lookup_template_function (fn, targs);
8329 tree purpose, value, chain;
8331 if (t == void_list_node)
8334 purpose = TREE_PURPOSE (t);
8336 purpose = tsubst_copy (purpose, args, complain, in_decl);
8337 value = TREE_VALUE (t);
8339 value = tsubst_copy (value, args, complain, in_decl);
8340 chain = TREE_CHAIN (t);
8341 if (chain && chain != void_type_node)
8342 chain = tsubst_copy (chain, args, complain, in_decl);
8343 if (purpose == TREE_PURPOSE (t)
8344 && value == TREE_VALUE (t)
8345 && chain == TREE_CHAIN (t))
8347 return tree_cons (purpose, value, chain);
8354 case TEMPLATE_TYPE_PARM:
8355 case TEMPLATE_TEMPLATE_PARM:
8356 case BOUND_TEMPLATE_TEMPLATE_PARM:
8357 case TEMPLATE_PARM_INDEX:
8359 case REFERENCE_TYPE:
8365 case UNBOUND_CLASS_TEMPLATE:
8368 return tsubst (t, args, complain, in_decl);
8370 case IDENTIFIER_NODE:
8371 if (IDENTIFIER_TYPENAME_P (t))
8373 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8374 return mangle_conv_op_name_for_type (new_type);
8380 /* This is handled by tsubst_copy_and_build. */
8384 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
8386 tsubst (TREE_TYPE (t), args, complain, in_decl));
8388 case CLEANUP_POINT_EXPR:
8389 /* We shouldn't have built any of these during initial template
8390 generation. Instead, they should be built during instantiation
8391 in response to the saved STMT_IS_FULL_EXPR_P setting. */
8395 mark_used (TREE_OPERAND (t, 1));
8403 /* Like tsubst_copy, but specifically for OpenMP clauses. */
8406 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
8409 tree new_clauses = NULL, nc, oc;
8411 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
8413 nc = copy_node (oc);
8414 OMP_CLAUSE_CHAIN (nc) = new_clauses;
8417 switch (OMP_CLAUSE_CODE (nc))
8419 case OMP_CLAUSE_PRIVATE:
8420 case OMP_CLAUSE_SHARED:
8421 case OMP_CLAUSE_FIRSTPRIVATE:
8422 case OMP_CLAUSE_LASTPRIVATE:
8423 case OMP_CLAUSE_REDUCTION:
8424 case OMP_CLAUSE_COPYIN:
8425 case OMP_CLAUSE_COPYPRIVATE:
8427 case OMP_CLAUSE_NUM_THREADS:
8428 case OMP_CLAUSE_SCHEDULE:
8429 OMP_CLAUSE_OPERAND (nc, 0)
8430 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
8431 in_decl, /*integral_constant_expression_p=*/false);
8433 case OMP_CLAUSE_NOWAIT:
8434 case OMP_CLAUSE_ORDERED:
8435 case OMP_CLAUSE_DEFAULT:
8442 return finish_omp_clauses (nreverse (new_clauses));
8445 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
8448 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
8451 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
8453 tree purpose, value, chain;
8458 if (TREE_CODE (t) != TREE_LIST)
8459 return tsubst_copy_and_build (t, args, complain, in_decl,
8460 /*function_p=*/false,
8461 /*integral_constant_expression_p=*/false);
8463 if (t == void_list_node)
8466 purpose = TREE_PURPOSE (t);
8468 purpose = RECUR (purpose);
8469 value = TREE_VALUE (t);
8471 value = RECUR (value);
8472 chain = TREE_CHAIN (t);
8473 if (chain && chain != void_type_node)
8474 chain = RECUR (chain);
8475 return tree_cons (purpose, value, chain);
8479 /* Like tsubst_copy for expressions, etc. but also does semantic
8483 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
8484 bool integral_constant_expression_p)
8486 #define RECUR(NODE) \
8487 tsubst_expr ((NODE), args, complain, in_decl, \
8488 integral_constant_expression_p)
8492 if (t == NULL_TREE || t == error_mark_node)
8495 if (EXPR_HAS_LOCATION (t))
8496 input_location = EXPR_LOCATION (t);
8497 if (STATEMENT_CODE_P (TREE_CODE (t)))
8498 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
8500 switch (TREE_CODE (t))
8502 case STATEMENT_LIST:
8504 tree_stmt_iterator i;
8505 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
8506 RECUR (tsi_stmt (i));
8510 case CTOR_INITIALIZER:
8511 finish_mem_initializers (tsubst_initializer_list
8512 (TREE_OPERAND (t, 0), args));
8516 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
8520 tmp = RECUR (EXPR_STMT_EXPR (t));
8521 if (EXPR_STMT_STMT_EXPR_RESULT (t))
8522 finish_stmt_expr_expr (tmp, cur_stmt_expr);
8524 finish_expr_stmt (tmp);
8528 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
8536 decl = DECL_EXPR_DECL (t);
8537 if (TREE_CODE (decl) == LABEL_DECL)
8538 finish_label_decl (DECL_NAME (decl));
8539 else if (TREE_CODE (decl) == USING_DECL)
8541 tree scope = USING_DECL_SCOPE (decl);
8542 tree name = DECL_NAME (decl);
8545 scope = RECUR (scope);
8546 decl = lookup_qualified_name (scope, name,
8547 /*is_type_p=*/false,
8548 /*complain=*/false);
8549 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
8550 qualified_name_lookup_error (scope, name, decl);
8552 do_local_using_decl (decl, scope, name);
8556 init = DECL_INITIAL (decl);
8557 decl = tsubst (decl, args, complain, in_decl);
8558 if (decl != error_mark_node)
8560 /* By marking the declaration as instantiated, we avoid
8561 trying to instantiate it. Since instantiate_decl can't
8562 handle local variables, and since we've already done
8563 all that needs to be done, that's the right thing to
8565 if (TREE_CODE (decl) == VAR_DECL)
8566 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8567 if (TREE_CODE (decl) == VAR_DECL
8568 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
8569 /* Anonymous aggregates are a special case. */
8570 finish_anon_union (decl);
8573 maybe_push_decl (decl);
8574 if (TREE_CODE (decl) == VAR_DECL
8575 && DECL_PRETTY_FUNCTION_P (decl))
8577 /* For __PRETTY_FUNCTION__ we have to adjust the
8579 const char *const name
8580 = cxx_printable_name (current_function_decl, 2);
8581 init = cp_fname_init (name, &TREE_TYPE (decl));
8584 init = RECUR (init);
8585 finish_decl (decl, init, NULL_TREE);
8590 /* A DECL_EXPR can also be used as an expression, in the condition
8591 clause of an if/for/while construct. */
8596 stmt = begin_for_stmt ();
8597 RECUR (FOR_INIT_STMT (t));
8598 finish_for_init_stmt (stmt);
8599 tmp = RECUR (FOR_COND (t));
8600 finish_for_cond (tmp, stmt);
8601 tmp = RECUR (FOR_EXPR (t));
8602 finish_for_expr (tmp, stmt);
8603 RECUR (FOR_BODY (t));
8604 finish_for_stmt (stmt);
8608 stmt = begin_while_stmt ();
8609 tmp = RECUR (WHILE_COND (t));
8610 finish_while_stmt_cond (tmp, stmt);
8611 RECUR (WHILE_BODY (t));
8612 finish_while_stmt (stmt);
8616 stmt = begin_do_stmt ();
8617 RECUR (DO_BODY (t));
8618 finish_do_body (stmt);
8619 tmp = RECUR (DO_COND (t));
8620 finish_do_stmt (tmp, stmt);
8624 stmt = begin_if_stmt ();
8625 tmp = RECUR (IF_COND (t));
8626 finish_if_stmt_cond (tmp, stmt);
8627 RECUR (THEN_CLAUSE (t));
8628 finish_then_clause (stmt);
8630 if (ELSE_CLAUSE (t))
8632 begin_else_clause (stmt);
8633 RECUR (ELSE_CLAUSE (t));
8634 finish_else_clause (stmt);
8637 finish_if_stmt (stmt);
8641 if (BIND_EXPR_BODY_BLOCK (t))
8642 stmt = begin_function_body ();
8644 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
8645 ? BCS_TRY_BLOCK : 0);
8647 RECUR (BIND_EXPR_BODY (t));
8649 if (BIND_EXPR_BODY_BLOCK (t))
8650 finish_function_body (stmt);
8652 finish_compound_stmt (stmt);
8656 finish_break_stmt ();
8660 finish_continue_stmt ();
8664 stmt = begin_switch_stmt ();
8665 tmp = RECUR (SWITCH_STMT_COND (t));
8666 finish_switch_cond (tmp, stmt);
8667 RECUR (SWITCH_STMT_BODY (t));
8668 finish_switch_stmt (stmt);
8671 case CASE_LABEL_EXPR:
8672 finish_case_label (RECUR (CASE_LOW (t)),
8673 RECUR (CASE_HIGH (t)));
8677 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
8681 tmp = GOTO_DESTINATION (t);
8682 if (TREE_CODE (tmp) != LABEL_DECL)
8683 /* Computed goto's must be tsubst'd into. On the other hand,
8684 non-computed gotos must not be; the identifier in question
8685 will have no binding. */
8688 tmp = DECL_NAME (tmp);
8689 finish_goto_stmt (tmp);
8693 tmp = finish_asm_stmt
8694 (ASM_VOLATILE_P (t),
8695 RECUR (ASM_STRING (t)),
8696 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
8697 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
8698 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
8700 tree asm_expr = tmp;
8701 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
8702 asm_expr = TREE_OPERAND (asm_expr, 0);
8703 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
8710 stmt = begin_try_block ();
8711 RECUR (TRY_STMTS (t));
8712 finish_cleanup_try_block (stmt);
8713 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
8717 tree compound_stmt = NULL_TREE;
8719 if (FN_TRY_BLOCK_P (t))
8720 stmt = begin_function_try_block (&compound_stmt);
8722 stmt = begin_try_block ();
8724 RECUR (TRY_STMTS (t));
8726 if (FN_TRY_BLOCK_P (t))
8727 finish_function_try_block (stmt);
8729 finish_try_block (stmt);
8731 RECUR (TRY_HANDLERS (t));
8732 if (FN_TRY_BLOCK_P (t))
8733 finish_function_handler_sequence (stmt, compound_stmt);
8735 finish_handler_sequence (stmt);
8741 tree decl = HANDLER_PARMS (t);
8745 decl = tsubst (decl, args, complain, in_decl);
8746 /* Prevent instantiate_decl from trying to instantiate
8747 this variable. We've already done all that needs to be
8749 if (decl != error_mark_node)
8750 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8752 stmt = begin_handler ();
8753 finish_handler_parms (decl, stmt);
8754 RECUR (HANDLER_BODY (t));
8755 finish_handler (stmt);
8760 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8764 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
8765 args, complain, in_decl);
8766 stmt = begin_omp_parallel ();
8767 RECUR (OMP_PARALLEL_BODY (t));
8768 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
8769 = OMP_PARALLEL_COMBINED (t);
8774 tree clauses, decl, init, cond, incr, body, pre_body;
8776 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
8777 args, complain, in_decl);
8778 init = OMP_FOR_INIT (t);
8779 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
8780 decl = RECUR (TREE_OPERAND (init, 0));
8781 init = RECUR (TREE_OPERAND (init, 1));
8782 cond = RECUR (OMP_FOR_COND (t));
8783 incr = RECUR (OMP_FOR_INCR (t));
8785 stmt = begin_omp_structured_block ();
8787 pre_body = push_stmt_list ();
8788 RECUR (OMP_FOR_PRE_BODY (t));
8789 pre_body = pop_stmt_list (pre_body);
8791 body = push_stmt_list ();
8792 RECUR (OMP_FOR_BODY (t));
8793 body = pop_stmt_list (body);
8795 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
8798 OMP_FOR_CLAUSES (t) = clauses;
8800 add_stmt (finish_omp_structured_block (stmt));
8806 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
8807 stmt = push_stmt_list ();
8808 RECUR (OMP_BODY (t));
8809 stmt = pop_stmt_list (stmt);
8812 OMP_BODY (t) = stmt;
8813 OMP_CLAUSES (t) = tmp;
8821 stmt = push_stmt_list ();
8822 RECUR (OMP_BODY (t));
8823 stmt = pop_stmt_list (stmt);
8826 OMP_BODY (t) = stmt;
8833 op0 = RECUR (TREE_OPERAND (t, 0));
8834 op1 = RECUR (TREE_OPERAND (t, 1));
8835 finish_omp_atomic (OMP_ATOMIC_CODE (t), op0, op1);
8840 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
8842 return tsubst_copy_and_build (t, args, complain, in_decl,
8843 /*function_p=*/false,
8844 integral_constant_expression_p);
8851 /* T is a postfix-expression that is not being used in a function
8852 call. Return the substituted version of T. */
8855 tsubst_non_call_postfix_expression (tree t, tree args,
8856 tsubst_flags_t complain,
8859 if (TREE_CODE (t) == SCOPE_REF)
8860 t = tsubst_qualified_id (t, args, complain, in_decl,
8861 /*done=*/false, /*address_p=*/false);
8863 t = tsubst_copy_and_build (t, args, complain, in_decl,
8864 /*function_p=*/false,
8865 /*integral_constant_expression_p=*/false);
8870 /* Like tsubst but deals with expressions and performs semantic
8871 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8874 tsubst_copy_and_build (tree t,
8876 tsubst_flags_t complain,
8879 bool integral_constant_expression_p)
8881 #define RECUR(NODE) \
8882 tsubst_copy_and_build (NODE, args, complain, in_decl, \
8883 /*function_p=*/false, \
8884 integral_constant_expression_p)
8888 if (t == NULL_TREE || t == error_mark_node)
8891 switch (TREE_CODE (t))
8896 case IDENTIFIER_NODE:
8900 bool non_integral_constant_expression_p;
8901 const char *error_msg;
8903 if (IDENTIFIER_TYPENAME_P (t))
8905 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8906 t = mangle_conv_op_name_for_type (new_type);
8909 /* Look up the name. */
8910 decl = lookup_name (t);
8912 /* By convention, expressions use ERROR_MARK_NODE to indicate
8913 failure, not NULL_TREE. */
8914 if (decl == NULL_TREE)
8915 decl = error_mark_node;
8917 decl = finish_id_expression (t, decl, NULL_TREE,
8919 integral_constant_expression_p,
8920 /*allow_non_integral_constant_expression_p=*/false,
8921 &non_integral_constant_expression_p,
8922 /*template_p=*/false,
8924 /*address_p=*/false,
8925 /*template_arg_p=*/false,
8929 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8930 decl = unqualified_name_lookup_error (decl);
8934 case TEMPLATE_ID_EXPR:
8937 tree template = RECUR (TREE_OPERAND (t, 0));
8938 tree targs = TREE_OPERAND (t, 1);
8941 targs = tsubst_template_args (targs, args, complain, in_decl);
8943 if (TREE_CODE (template) == COMPONENT_REF)
8945 object = TREE_OPERAND (template, 0);
8946 template = TREE_OPERAND (template, 1);
8950 template = lookup_template_function (template, targs);
8953 return build3 (COMPONENT_REF, TREE_TYPE (template),
8954 object, template, NULL_TREE);
8956 return baselink_for_fns (template);
8961 tree r = RECUR (TREE_OPERAND (t, 0));
8963 if (REFERENCE_REF_P (t))
8965 /* A type conversion to reference type will be enclosed in
8966 such an indirect ref, but the substitution of the cast
8967 will have also added such an indirect ref. */
8968 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
8969 r = convert_from_reference (r);
8972 r = build_x_indirect_ref (r, "unary *");
8978 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8979 RECUR (TREE_OPERAND (t, 0)));
8982 case REINTERPRET_CAST_EXPR:
8983 case CONST_CAST_EXPR:
8984 case DYNAMIC_CAST_EXPR:
8985 case STATIC_CAST_EXPR:
8990 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8991 if (integral_constant_expression_p
8992 && !cast_valid_in_integral_constant_expression_p (type))
8994 error ("a cast to a type other than an integral or "
8995 "enumeration type cannot appear in a constant-expression");
8996 return error_mark_node;
8999 op = RECUR (TREE_OPERAND (t, 0));
9001 switch (TREE_CODE (t))
9004 return build_functional_cast (type, op);
9005 case REINTERPRET_CAST_EXPR:
9006 return build_reinterpret_cast (type, op);
9007 case CONST_CAST_EXPR:
9008 return build_const_cast (type, op);
9009 case DYNAMIC_CAST_EXPR:
9010 return build_dynamic_cast (type, op);
9011 case STATIC_CAST_EXPR:
9012 return build_static_cast (type, op);
9018 case POSTDECREMENT_EXPR:
9019 case POSTINCREMENT_EXPR:
9020 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9021 args, complain, in_decl);
9022 return build_x_unary_op (TREE_CODE (t), op1);
9024 case PREDECREMENT_EXPR:
9025 case PREINCREMENT_EXPR:
9029 case TRUTH_NOT_EXPR:
9030 case UNARY_PLUS_EXPR: /* Unary + */
9033 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
9036 op1 = TREE_OPERAND (t, 0);
9037 if (TREE_CODE (op1) == SCOPE_REF)
9038 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
9039 /*done=*/true, /*address_p=*/true);
9041 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
9043 if (TREE_CODE (op1) == LABEL_DECL)
9044 return finish_label_address_expr (DECL_NAME (op1));
9045 return build_x_unary_op (ADDR_EXPR, op1);
9050 case TRUNC_DIV_EXPR:
9052 case FLOOR_DIV_EXPR:
9053 case ROUND_DIV_EXPR:
9054 case EXACT_DIV_EXPR:
9058 case TRUNC_MOD_EXPR:
9059 case FLOOR_MOD_EXPR:
9060 case TRUTH_ANDIF_EXPR:
9061 case TRUTH_ORIF_EXPR:
9062 case TRUTH_AND_EXPR:
9078 return build_x_binary_op
9080 RECUR (TREE_OPERAND (t, 0)),
9081 RECUR (TREE_OPERAND (t, 1)),
9082 /*overloaded_p=*/NULL);
9085 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
9086 /*address_p=*/false);
9088 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9089 args, complain, in_decl);
9090 return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)),
9091 /*overloaded_p=*/NULL);
9095 op1 = TREE_OPERAND (t, 0);
9098 /* When there are no ARGS, we are trying to evaluate a
9099 non-dependent expression from the parser. Trying to do
9100 the substitutions may not work. */
9102 op1 = TREE_TYPE (op1);
9107 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
9108 /*function_p=*/false,
9109 /*integral_constant_expression_p=*/false);
9113 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
9115 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
9119 tree r = build_x_modify_expr
9120 (RECUR (TREE_OPERAND (t, 0)),
9121 TREE_CODE (TREE_OPERAND (t, 1)),
9122 RECUR (TREE_OPERAND (t, 2)));
9123 /* TREE_NO_WARNING must be set if either the expression was
9124 parenthesized or it uses an operator such as >>= rather
9125 than plain assignment. In the former case, it was already
9126 set and must be copied. In the latter case,
9127 build_x_modify_expr sets it and it must not be reset
9129 if (TREE_NO_WARNING (t))
9130 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9135 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9136 args, complain, in_decl);
9137 /* Remember that there was a reference to this entity. */
9140 return build_x_arrow (op1);
9144 (RECUR (TREE_OPERAND (t, 0)),
9145 RECUR (TREE_OPERAND (t, 1)),
9146 RECUR (TREE_OPERAND (t, 2)),
9147 RECUR (TREE_OPERAND (t, 3)),
9148 NEW_EXPR_USE_GLOBAL (t));
9151 return delete_sanity
9152 (RECUR (TREE_OPERAND (t, 0)),
9153 RECUR (TREE_OPERAND (t, 1)),
9154 DELETE_EXPR_USE_VEC (t),
9155 DELETE_EXPR_USE_GLOBAL (t));
9158 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
9159 RECUR (TREE_OPERAND (t, 1)));
9168 function = TREE_OPERAND (t, 0);
9169 /* When we parsed the expression, we determined whether or
9170 not Koenig lookup should be performed. */
9171 koenig_p = KOENIG_LOOKUP_P (t);
9172 if (TREE_CODE (function) == SCOPE_REF)
9175 function = tsubst_qualified_id (function, args, complain, in_decl,
9177 /*address_p=*/false);
9181 if (TREE_CODE (function) == COMPONENT_REF)
9183 tree op = TREE_OPERAND (function, 1);
9185 qualified_p = (TREE_CODE (op) == SCOPE_REF
9187 && BASELINK_QUALIFIED_P (op)));
9190 qualified_p = false;
9192 function = tsubst_copy_and_build (function, args, complain,
9195 integral_constant_expression_p);
9197 if (BASELINK_P (function))
9201 call_args = RECUR (TREE_OPERAND (t, 1));
9203 /* We do not perform argument-dependent lookup if normal
9204 lookup finds a non-function, in accordance with the
9205 expected resolution of DR 218. */
9207 && ((is_overloaded_fn (function)
9208 /* If lookup found a member function, the Koenig lookup is
9209 not appropriate, even if an unqualified-name was used
9210 to denote the function. */
9211 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
9212 || TREE_CODE (function) == IDENTIFIER_NODE))
9213 function = perform_koenig_lookup (function, call_args);
9215 if (TREE_CODE (function) == IDENTIFIER_NODE)
9217 unqualified_name_lookup_error (function);
9218 return error_mark_node;
9221 /* Remember that there was a reference to this entity. */
9222 if (DECL_P (function))
9223 mark_used (function);
9225 if (TREE_CODE (function) == OFFSET_REF)
9226 return build_offset_ref_call_from_tree (function, call_args);
9227 if (TREE_CODE (function) == COMPONENT_REF)
9229 if (!BASELINK_P (TREE_OPERAND (function, 1)))
9230 return finish_call_expr (function, call_args,
9231 /*disallow_virtual=*/false,
9232 /*koenig_p=*/false);
9234 return (build_new_method_call
9235 (TREE_OPERAND (function, 0),
9236 TREE_OPERAND (function, 1),
9237 call_args, NULL_TREE,
9238 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
9241 return finish_call_expr (function, call_args,
9242 /*disallow_virtual=*/qualified_p,
9247 return build_x_conditional_expr
9248 (RECUR (TREE_OPERAND (t, 0)),
9249 RECUR (TREE_OPERAND (t, 1)),
9250 RECUR (TREE_OPERAND (t, 2)));
9252 case PSEUDO_DTOR_EXPR:
9253 return finish_pseudo_destructor_expr
9254 (RECUR (TREE_OPERAND (t, 0)),
9255 RECUR (TREE_OPERAND (t, 1)),
9256 RECUR (TREE_OPERAND (t, 2)));
9260 tree purpose, value, chain;
9262 if (t == void_list_node)
9265 purpose = TREE_PURPOSE (t);
9267 purpose = RECUR (purpose);
9268 value = TREE_VALUE (t);
9270 value = RECUR (value);
9271 chain = TREE_CHAIN (t);
9272 if (chain && chain != void_type_node)
9273 chain = RECUR (chain);
9274 if (purpose == TREE_PURPOSE (t)
9275 && value == TREE_VALUE (t)
9276 && chain == TREE_CHAIN (t))
9278 return tree_cons (purpose, value, chain);
9287 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9288 args, complain, in_decl);
9289 /* Remember that there was a reference to this entity. */
9290 if (DECL_P (object))
9292 object_type = TREE_TYPE (object);
9294 member = TREE_OPERAND (t, 1);
9295 if (BASELINK_P (member))
9296 member = tsubst_baselink (member,
9297 non_reference (TREE_TYPE (object)),
9298 args, complain, in_decl);
9300 member = tsubst_copy (member, args, complain, in_decl);
9301 if (member == error_mark_node)
9302 return error_mark_node;
9304 if (object_type && !CLASS_TYPE_P (object_type))
9306 if (TREE_CODE (member) == BIT_NOT_EXPR)
9307 return finish_pseudo_destructor_expr (object,
9310 else if (TREE_CODE (member) == SCOPE_REF
9311 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
9312 return finish_pseudo_destructor_expr (object,
9316 else if (TREE_CODE (member) == SCOPE_REF
9317 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
9322 /* Lookup the template functions now that we know what the
9324 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
9325 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
9326 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
9327 /*is_type_p=*/false,
9328 /*complain=*/false);
9329 if (BASELINK_P (member))
9331 BASELINK_FUNCTIONS (member)
9332 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
9334 member = (adjust_result_of_qualified_name_lookup
9335 (member, BINFO_TYPE (BASELINK_BINFO (member)),
9340 qualified_name_lookup_error (object_type, tmpl, member);
9341 return error_mark_node;
9344 else if (TREE_CODE (member) == SCOPE_REF
9345 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
9346 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
9348 if (complain & tf_error)
9350 if (TYPE_P (TREE_OPERAND (member, 0)))
9351 error ("%qT is not a class or namespace",
9352 TREE_OPERAND (member, 0));
9354 error ("%qD is not a class or namespace",
9355 TREE_OPERAND (member, 0));
9357 return error_mark_node;
9359 else if (TREE_CODE (member) == FIELD_DECL)
9360 return finish_non_static_data_member (member, object, NULL_TREE);
9362 return finish_class_member_access_expr (object, member,
9363 /*template_p=*/false);
9368 (RECUR (TREE_OPERAND (t, 0)));
9372 VEC(constructor_elt,gc) *n;
9373 constructor_elt *ce;
9374 unsigned HOST_WIDE_INT idx;
9375 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9376 bool process_index_p;
9378 if (type == error_mark_node)
9379 return error_mark_node;
9381 /* digest_init will do the wrong thing if we let it. */
9382 if (type && TYPE_PTRMEMFUNC_P (type))
9385 /* We do not want to process the index of aggregate
9386 initializers as they are identifier nodes which will be
9387 looked up by digest_init. */
9388 process_index_p = !(type && IS_AGGR_TYPE (type));
9390 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
9391 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
9393 if (ce->index && process_index_p)
9394 ce->index = RECUR (ce->index);
9395 ce->value = RECUR (ce->value);
9398 if (TREE_HAS_CONSTRUCTOR (t))
9399 return finish_compound_literal (type, n);
9401 return build_constructor (NULL_TREE, n);
9406 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
9407 if (TYPE_P (operand_0))
9408 return get_typeid (operand_0);
9409 return build_typeid (operand_0);
9419 tree r = tsubst_copy (t, args, complain, in_decl);
9421 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
9422 /* If the original type was a reference, we'll be wrapped in
9423 the appropriate INDIRECT_REF. */
9424 r = convert_from_reference (r);
9429 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
9430 tsubst_copy (TREE_TYPE (t), args, complain,
9434 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
9438 tree old_stmt_expr = cur_stmt_expr;
9439 tree stmt_expr = begin_stmt_expr ();
9441 cur_stmt_expr = stmt_expr;
9442 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
9443 integral_constant_expression_p);
9444 stmt_expr = finish_stmt_expr (stmt_expr, false);
9445 cur_stmt_expr = old_stmt_expr;
9451 t = tsubst_copy (t, args, complain, in_decl);
9452 /* As in finish_id_expression, we resolve enumeration constants
9453 to their underlying values. */
9454 if (TREE_CODE (t) == CONST_DECL)
9456 used_types_insert (TREE_TYPE (t));
9457 return DECL_INITIAL (t);
9462 /* Handle Objective-C++ constructs, if appropriate. */
9465 = objcp_tsubst_copy_and_build (t, args, complain,
9466 in_decl, /*function_p=*/false);
9470 return tsubst_copy (t, args, complain, in_decl);
9476 /* Verify that the instantiated ARGS are valid. For type arguments,
9477 make sure that the type's linkage is ok. For non-type arguments,
9478 make sure they are constants if they are integral or enumerations.
9479 Emit an error under control of COMPLAIN, and return TRUE on error. */
9482 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
9484 int ix, len = DECL_NTPARMS (tmpl);
9485 bool result = false;
9487 for (ix = 0; ix != len; ix++)
9489 tree t = TREE_VEC_ELT (args, ix);
9493 /* [basic.link]: A name with no linkage (notably, the name
9494 of a class or enumeration declared in a local scope)
9495 shall not be used to declare an entity with linkage.
9496 This implies that names with no linkage cannot be used as
9497 template arguments. */
9498 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
9502 /* DR 488 makes use of a type with no linkage cause
9503 type deduction to fail. */
9504 if (complain & tf_error)
9506 if (TYPE_ANONYMOUS_P (nt))
9507 error ("%qT is/uses anonymous type", t);
9509 error ("template argument for %qD uses local type %qT",
9514 /* In order to avoid all sorts of complications, we do not
9515 allow variably-modified types as template arguments. */
9516 else if (variably_modified_type_p (t, NULL_TREE))
9518 if (complain & tf_error)
9519 error ("%qT is a variably modified type", t);
9523 /* A non-type argument of integral or enumerated type must be a
9525 else if (TREE_TYPE (t)
9526 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
9527 && !TREE_CONSTANT (t))
9529 if (complain & tf_error)
9530 error ("integral expression %qE is not constant", t);
9534 if (result && (complain & tf_error))
9535 error (" trying to instantiate %qD", tmpl);
9539 /* Instantiate the indicated variable or function template TMPL with
9540 the template arguments in TARG_PTR. */
9543 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
9548 HOST_WIDE_INT saved_processing_template_decl;
9550 if (tmpl == error_mark_node)
9551 return error_mark_node;
9553 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
9555 /* If this function is a clone, handle it specially. */
9556 if (DECL_CLONED_FUNCTION_P (tmpl))
9561 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
9563 if (spec == error_mark_node)
9564 return error_mark_node;
9566 /* Look for the clone. */
9567 FOR_EACH_CLONE (clone, spec)
9568 if (DECL_NAME (clone) == DECL_NAME (tmpl))
9570 /* We should always have found the clone by now. */
9575 /* Check to see if we already have this specialization. */
9576 spec = retrieve_specialization (tmpl, targ_ptr,
9577 /*class_specializations_p=*/false);
9578 if (spec != NULL_TREE)
9581 gen_tmpl = most_general_template (tmpl);
9582 if (tmpl != gen_tmpl)
9584 /* The TMPL is a partial instantiation. To get a full set of
9585 arguments we must add the arguments used to perform the
9586 partial instantiation. */
9587 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
9590 /* Check to see if we already have this specialization. */
9591 spec = retrieve_specialization (gen_tmpl, targ_ptr,
9592 /*class_specializations_p=*/false);
9593 if (spec != NULL_TREE)
9597 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
9599 return error_mark_node;
9601 /* We are building a FUNCTION_DECL, during which the access of its
9602 parameters and return types have to be checked. However this
9603 FUNCTION_DECL which is the desired context for access checking
9604 is not built yet. We solve this chicken-and-egg problem by
9605 deferring all checks until we have the FUNCTION_DECL. */
9606 push_deferring_access_checks (dk_deferred);
9608 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
9609 (because, for example, we have encountered a non-dependent
9610 function call in the body of a template function and must now
9611 determine which of several overloaded functions will be called),
9612 within the instantiation itself we are not processing a
9614 saved_processing_template_decl = processing_template_decl;
9615 processing_template_decl = 0;
9616 /* Substitute template parameters to obtain the specialization. */
9617 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
9618 targ_ptr, complain, gen_tmpl);
9619 processing_template_decl = saved_processing_template_decl;
9620 if (fndecl == error_mark_node)
9621 return error_mark_node;
9623 /* Now we know the specialization, compute access previously
9625 push_access_scope (fndecl);
9626 perform_deferred_access_checks ();
9627 pop_access_scope (fndecl);
9628 pop_deferring_access_checks ();
9630 /* The DECL_TI_TEMPLATE should always be the immediate parent
9631 template, not the most general template. */
9632 DECL_TI_TEMPLATE (fndecl) = tmpl;
9634 /* If we've just instantiated the main entry point for a function,
9635 instantiate all the alternate entry points as well. We do this
9636 by cloning the instantiation of the main entry point, not by
9637 instantiating the template clones. */
9638 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
9639 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
9644 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
9645 arguments that are being used when calling it. TARGS is a vector
9646 into which the deduced template arguments are placed.
9648 Return zero for success, 2 for an incomplete match that doesn't resolve
9649 all the types, and 1 for complete failure. An error message will be
9650 printed only for an incomplete match.
9652 If FN is a conversion operator, or we are trying to produce a specific
9653 specialization, RETURN_TYPE is the return type desired.
9655 The EXPLICIT_TARGS are explicit template arguments provided via a
9658 The parameter STRICT is one of:
9661 We are deducing arguments for a function call, as in
9665 We are deducing arguments for a conversion function, as in
9669 We are deducing arguments when doing an explicit instantiation
9670 as in [temp.explicit], when determining an explicit specialization
9671 as in [temp.expl.spec], or when taking the address of a function
9672 template, as in [temp.deduct.funcaddr]. */
9675 fn_type_unification (tree fn,
9676 tree explicit_targs,
9680 unification_kind_t strict,
9687 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
9689 fntype = TREE_TYPE (fn);
9694 The specified template arguments must match the template
9695 parameters in kind (i.e., type, nontype, template), and there
9696 must not be more arguments than there are parameters;
9697 otherwise type deduction fails.
9699 Nontype arguments must match the types of the corresponding
9700 nontype template parameters, or must be convertible to the
9701 types of the corresponding nontype parameters as specified in
9702 _temp.arg.nontype_, otherwise type deduction fails.
9704 All references in the function type of the function template
9705 to the corresponding template parameters are replaced by the
9706 specified template argument values. If a substitution in a
9707 template parameter or in the function type of the function
9708 template results in an invalid type, type deduction fails. */
9710 tree converted_args;
9713 if (explicit_targs == error_mark_node)
9717 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9718 explicit_targs, NULL_TREE, tf_none,
9719 /*require_all_args=*/false,
9720 /*use_default_args=*/false));
9721 if (converted_args == error_mark_node)
9724 /* Substitute the explicit args into the function type. This is
9725 necessary so that, for instance, explicitly declared function
9726 arguments can match null pointed constants. If we were given
9727 an incomplete set of explicit args, we must not do semantic
9728 processing during substitution as we could create partial
9730 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
9731 processing_template_decl += incomplete;
9732 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
9733 processing_template_decl -= incomplete;
9735 if (fntype == error_mark_node)
9738 /* Place the explicitly specified arguments in TARGS. */
9739 for (i = NUM_TMPL_ARGS (converted_args); i--;)
9740 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
9743 /* Never do unification on the 'this' parameter. */
9744 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
9748 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
9749 args = tree_cons (NULL_TREE, return_type, args);
9752 /* We allow incomplete unification without an error message here
9753 because the standard doesn't seem to explicitly prohibit it. Our
9754 callers must be ready to deal with unification failures in any
9756 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9757 targs, parms, args, /*subr=*/0,
9761 /* All is well so far. Now, check:
9765 When all template arguments have been deduced, all uses of
9766 template parameters in nondeduced contexts are replaced with
9767 the corresponding deduced argument values. If the
9768 substitution results in an invalid type, as described above,
9769 type deduction fails. */
9770 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
9777 /* Adjust types before performing type deduction, as described in
9778 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
9779 sections are symmetric. PARM is the type of a function parameter
9780 or the return type of the conversion function. ARG is the type of
9781 the argument passed to the call, or the type of the value
9782 initialized with the result of the conversion function. */
9785 maybe_adjust_types_for_deduction (unification_kind_t strict,
9798 /* Swap PARM and ARG throughout the remainder of this
9799 function; the handling is precisely symmetric since PARM
9800 will initialize ARG rather than vice versa. */
9808 /* There is nothing to do in this case. */
9815 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9817 /* [temp.deduct.call]
9819 If P is not a reference type:
9821 --If A is an array type, the pointer type produced by the
9822 array-to-pointer standard conversion (_conv.array_) is
9823 used in place of A for type deduction; otherwise,
9825 --If A is a function type, the pointer type produced by
9826 the function-to-pointer standard conversion
9827 (_conv.func_) is used in place of A for type deduction;
9830 --If A is a cv-qualified type, the top level
9831 cv-qualifiers of A's type are ignored for type
9833 if (TREE_CODE (*arg) == ARRAY_TYPE)
9834 *arg = build_pointer_type (TREE_TYPE (*arg));
9835 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9836 *arg = build_pointer_type (*arg);
9838 *arg = TYPE_MAIN_VARIANT (*arg);
9841 /* [temp.deduct.call]
9843 If P is a cv-qualified type, the top level cv-qualifiers
9844 of P's type are ignored for type deduction. If P is a
9845 reference type, the type referred to by P is used for
9847 *parm = TYPE_MAIN_VARIANT (*parm);
9848 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9850 *parm = TREE_TYPE (*parm);
9851 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9854 /* DR 322. For conversion deduction, remove a reference type on parm
9855 too (which has been swapped into ARG). */
9856 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9857 *arg = TREE_TYPE (*arg);
9862 /* Most parms like fn_type_unification.
9864 If SUBR is 1, we're being called recursively (to unify the
9865 arguments of a function or method parameter of a function
9869 type_unification_real (tree tparms,
9874 unification_kind_t strict,
9879 int ntparms = TREE_VEC_LENGTH (tparms);
9881 int saw_undeduced = 0;
9884 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
9885 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
9886 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
9887 gcc_assert (ntparms > 0);
9892 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9893 | UNIFY_ALLOW_DERIVED);
9897 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9901 sub_strict = UNIFY_ALLOW_NONE;
9912 while (parms && parms != void_list_node
9913 && args && args != void_list_node)
9915 parm = TREE_VALUE (parms);
9916 parms = TREE_CHAIN (parms);
9917 arg = TREE_VALUE (args);
9918 args = TREE_CHAIN (args);
9920 if (arg == error_mark_node)
9922 if (arg == unknown_type_node)
9923 /* We can't deduce anything from this, but we might get all the
9924 template args from other function args. */
9927 /* Conversions will be performed on a function argument that
9928 corresponds with a function parameter that contains only
9929 non-deducible template parameters and explicitly specified
9930 template parameters. */
9931 if (!uses_template_parms (parm))
9936 type = TREE_TYPE (arg);
9940 if (same_type_p (parm, type))
9942 if (strict != DEDUCE_EXACT
9943 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
9952 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
9953 if (type_unknown_p (arg))
9955 /* [temp.deduct.type]
9957 A template-argument can be deduced from a pointer to
9958 function or pointer to member function argument if
9959 the set of overloaded functions does not contain
9960 function templates and at most one of a set of
9961 overloaded functions provides a unique match. */
9962 if (resolve_overloaded_unification
9963 (tparms, targs, parm, arg, strict, sub_strict))
9968 arg = unlowered_expr_type (arg);
9969 if (arg == error_mark_node)
9974 int arg_strict = sub_strict;
9977 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9979 if (unify (tparms, targs, parm, arg, arg_strict))
9984 /* Fail if we've reached the end of the parm list, and more args
9985 are present, and the parm list isn't variadic. */
9986 if (args && args != void_list_node && parms == void_list_node)
9988 /* Fail if parms are left and they don't have default values. */
9989 if (parms && parms != void_list_node
9990 && TREE_PURPOSE (parms) == NULL_TREE)
9994 for (i = 0; i < ntparms; i++)
9995 if (!TREE_VEC_ELT (targs, i))
9999 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
10002 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
10004 /* If this is an undeduced nontype parameter that depends on
10005 a type parameter, try another pass; its type may have been
10006 deduced from a later argument than the one from which
10007 this parameter can be deduced. */
10008 if (TREE_CODE (tparm) == PARM_DECL
10009 && uses_template_parms (TREE_TYPE (tparm))
10010 && !saw_undeduced++)
10019 /* Subroutine of type_unification_real. Args are like the variables
10020 at the call site. ARG is an overloaded function (or template-id);
10021 we try deducing template args from each of the overloads, and if
10022 only one succeeds, we go with that. Modifies TARGS and returns
10023 true on success. */
10026 resolve_overloaded_unification (tree tparms,
10030 unification_kind_t strict,
10033 tree tempargs = copy_node (targs);
10037 if (TREE_CODE (arg) == ADDR_EXPR)
10039 arg = TREE_OPERAND (arg, 0);
10045 if (TREE_CODE (arg) == COMPONENT_REF)
10046 /* Handle `&x' where `x' is some static or non-static member
10048 arg = TREE_OPERAND (arg, 1);
10050 if (TREE_CODE (arg) == OFFSET_REF)
10051 arg = TREE_OPERAND (arg, 1);
10053 /* Strip baselink information. */
10054 if (BASELINK_P (arg))
10055 arg = BASELINK_FUNCTIONS (arg);
10057 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
10059 /* If we got some explicit template args, we need to plug them into
10060 the affected templates before we try to unify, in case the
10061 explicit args will completely resolve the templates in question. */
10063 tree expl_subargs = TREE_OPERAND (arg, 1);
10064 arg = TREE_OPERAND (arg, 0);
10066 for (; arg; arg = OVL_NEXT (arg))
10068 tree fn = OVL_CURRENT (arg);
10069 tree subargs, elem;
10071 if (TREE_CODE (fn) != TEMPLATE_DECL)
10074 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
10075 expl_subargs, /*check_ret=*/false);
10078 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
10079 good += try_one_overload (tparms, targs, tempargs, parm,
10080 elem, strict, sub_strict, addr_p);
10084 else if (TREE_CODE (arg) != OVERLOAD
10085 && TREE_CODE (arg) != FUNCTION_DECL)
10086 /* If ARG is, for example, "(0, &f)" then its type will be unknown
10087 -- but the deduction does not succeed because the expression is
10088 not just the function on its own. */
10091 for (; arg; arg = OVL_NEXT (arg))
10092 good += try_one_overload (tparms, targs, tempargs, parm,
10093 TREE_TYPE (OVL_CURRENT (arg)),
10094 strict, sub_strict, addr_p);
10096 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10097 to function or pointer to member function argument if the set of
10098 overloaded functions does not contain function templates and at most
10099 one of a set of overloaded functions provides a unique match.
10101 So if we found multiple possibilities, we return success but don't
10102 deduce anything. */
10106 int i = TREE_VEC_LENGTH (targs);
10108 if (TREE_VEC_ELT (tempargs, i))
10109 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
10117 /* Subroutine of resolve_overloaded_unification; does deduction for a single
10118 overload. Fills TARGS with any deduced arguments, or error_mark_node if
10119 different overloads deduce different arguments for a given parm.
10120 ADDR_P is true if the expression for which deduction is being
10121 performed was of the form "& fn" rather than simply "fn".
10123 Returns 1 on success. */
10126 try_one_overload (tree tparms,
10131 unification_kind_t strict,
10139 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10140 to function or pointer to member function argument if the set of
10141 overloaded functions does not contain function templates and at most
10142 one of a set of overloaded functions provides a unique match.
10144 So if this is a template, just return success. */
10146 if (uses_template_parms (arg))
10149 if (TREE_CODE (arg) == METHOD_TYPE)
10150 arg = build_ptrmemfunc_type (build_pointer_type (arg));
10152 arg = build_pointer_type (arg);
10154 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
10156 /* We don't copy orig_targs for this because if we have already deduced
10157 some template args from previous args, unify would complain when we
10158 try to deduce a template parameter for the same argument, even though
10159 there isn't really a conflict. */
10160 nargs = TREE_VEC_LENGTH (targs);
10161 tempargs = make_tree_vec (nargs);
10163 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
10166 /* First make sure we didn't deduce anything that conflicts with
10167 explicitly specified args. */
10168 for (i = nargs; i--; )
10170 tree elt = TREE_VEC_ELT (tempargs, i);
10171 tree oldelt = TREE_VEC_ELT (orig_targs, i);
10175 else if (uses_template_parms (elt))
10176 /* Since we're unifying against ourselves, we will fill in
10177 template args used in the function parm list with our own
10178 template parms. Discard them. */
10179 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
10180 else if (oldelt && !template_args_equal (oldelt, elt))
10184 for (i = nargs; i--; )
10186 tree elt = TREE_VEC_ELT (tempargs, i);
10189 TREE_VEC_ELT (targs, i) = elt;
10195 /* PARM is a template class (perhaps with unbound template
10196 parameters). ARG is a fully instantiated type. If ARG can be
10197 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
10198 TARGS are as for unify. */
10201 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
10203 tree copy_of_targs;
10205 if (!CLASSTYPE_TEMPLATE_INFO (arg)
10206 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
10207 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
10210 /* We need to make a new template argument vector for the call to
10211 unify. If we used TARGS, we'd clutter it up with the result of
10212 the attempted unification, even if this class didn't work out.
10213 We also don't want to commit ourselves to all the unifications
10214 we've already done, since unification is supposed to be done on
10215 an argument-by-argument basis. In other words, consider the
10216 following pathological case:
10218 template <int I, int J, int K>
10221 template <int I, int J>
10222 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
10224 template <int I, int J, int K>
10225 void f(S<I, J, K>, S<I, I, I>);
10234 Now, by the time we consider the unification involving `s2', we
10235 already know that we must have `f<0, 0, 0>'. But, even though
10236 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
10237 because there are two ways to unify base classes of S<0, 1, 2>
10238 with S<I, I, I>. If we kept the already deduced knowledge, we
10239 would reject the possibility I=1. */
10240 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
10242 /* If unification failed, we're done. */
10243 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
10244 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
10250 /* Given a template type PARM and a class type ARG, find the unique
10251 base type in ARG that is an instance of PARM. We do not examine
10252 ARG itself; only its base-classes. If there is not exactly one
10253 appropriate base class, return NULL_TREE. PARM may be the type of
10254 a partial specialization, as well as a plain template type. Used
10258 get_template_base (tree tparms, tree targs, tree parm, tree arg)
10260 tree rval = NULL_TREE;
10263 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
10265 binfo = TYPE_BINFO (complete_type (arg));
10267 /* The type could not be completed. */
10270 /* Walk in inheritance graph order. The search order is not
10271 important, and this avoids multiple walks of virtual bases. */
10272 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
10274 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
10278 /* If there is more than one satisfactory baseclass, then:
10282 If they yield more than one possible deduced A, the type
10286 if (rval && !same_type_p (r, rval))
10296 /* Returns the level of DECL, which declares a template parameter. */
10299 template_decl_level (tree decl)
10301 switch (TREE_CODE (decl))
10304 case TEMPLATE_DECL:
10305 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
10308 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
10311 gcc_unreachable ();
10316 /* Decide whether ARG can be unified with PARM, considering only the
10317 cv-qualifiers of each type, given STRICT as documented for unify.
10318 Returns nonzero iff the unification is OK on that basis. */
10321 check_cv_quals_for_unify (int strict, tree arg, tree parm)
10323 int arg_quals = cp_type_quals (arg);
10324 int parm_quals = cp_type_quals (parm);
10326 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10327 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10329 /* Although a CVR qualifier is ignored when being applied to a
10330 substituted template parameter ([8.3.2]/1 for example), that
10331 does not apply during deduction [14.8.2.4]/1, (even though
10332 that is not explicitly mentioned, [14.8.2.4]/9 indicates
10333 this). Except when we're allowing additional CV qualifiers
10334 at the outer level [14.8.2.1]/3,1st bullet. */
10335 if ((TREE_CODE (arg) == REFERENCE_TYPE
10336 || TREE_CODE (arg) == FUNCTION_TYPE
10337 || TREE_CODE (arg) == METHOD_TYPE)
10338 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
10341 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
10342 && (parm_quals & TYPE_QUAL_RESTRICT))
10346 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10347 && (arg_quals & parm_quals) != parm_quals)
10350 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
10351 && (parm_quals & arg_quals) != arg_quals)
10357 /* Deduce the value of template parameters. TPARMS is the (innermost)
10358 set of template parameters to a template. TARGS is the bindings
10359 for those template parameters, as determined thus far; TARGS may
10360 include template arguments for outer levels of template parameters
10361 as well. PARM is a parameter to a template function, or a
10362 subcomponent of that parameter; ARG is the corresponding argument.
10363 This function attempts to match PARM with ARG in a manner
10364 consistent with the existing assignments in TARGS. If more values
10365 are deduced, then TARGS is updated.
10367 Returns 0 if the type deduction succeeds, 1 otherwise. The
10368 parameter STRICT is a bitwise or of the following flags:
10371 Require an exact match between PARM and ARG.
10372 UNIFY_ALLOW_MORE_CV_QUAL:
10373 Allow the deduced ARG to be more cv-qualified (by qualification
10374 conversion) than ARG.
10375 UNIFY_ALLOW_LESS_CV_QUAL:
10376 Allow the deduced ARG to be less cv-qualified than ARG.
10377 UNIFY_ALLOW_DERIVED:
10378 Allow the deduced ARG to be a template base class of ARG,
10379 or a pointer to a template base class of the type pointed to by
10381 UNIFY_ALLOW_INTEGER:
10382 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
10383 case for more information.
10384 UNIFY_ALLOW_OUTER_LEVEL:
10385 This is the outermost level of a deduction. Used to determine validity
10386 of qualification conversions. A valid qualification conversion must
10387 have const qualified pointers leading up to the inner type which
10388 requires additional CV quals, except at the outer level, where const
10389 is not required [conv.qual]. It would be normal to set this flag in
10390 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
10391 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
10392 This is the outermost level of a deduction, and PARM can be more CV
10393 qualified at this point.
10394 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
10395 This is the outermost level of a deduction, and PARM can be less CV
10396 qualified at this point. */
10399 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
10404 int strict_in = strict;
10406 /* I don't think this will do the right thing with respect to types.
10407 But the only case I've seen it in so far has been array bounds, where
10408 signedness is the only information lost, and I think that will be
10410 while (TREE_CODE (parm) == NOP_EXPR)
10411 parm = TREE_OPERAND (parm, 0);
10413 if (arg == error_mark_node)
10415 if (arg == unknown_type_node)
10416 /* We can't deduce anything from this, but we might get all the
10417 template args from other function args. */
10420 /* If PARM uses template parameters, then we can't bail out here,
10421 even if ARG == PARM, since we won't record unifications for the
10422 template parameters. We might need them if we're trying to
10423 figure out which of two things is more specialized. */
10424 if (arg == parm && !uses_template_parms (parm))
10427 /* Immediately reject some pairs that won't unify because of
10428 cv-qualification mismatches. */
10429 if (TREE_CODE (arg) == TREE_CODE (parm)
10431 /* It is the elements of the array which hold the cv quals of an array
10432 type, and the elements might be template type parms. We'll check
10433 when we recurse. */
10434 && TREE_CODE (arg) != ARRAY_TYPE
10435 /* We check the cv-qualifiers when unifying with template type
10436 parameters below. We want to allow ARG `const T' to unify with
10437 PARM `T' for example, when computing which of two templates
10438 is more specialized, for example. */
10439 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
10440 && !check_cv_quals_for_unify (strict_in, arg, parm))
10443 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
10444 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
10445 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
10446 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
10447 strict &= ~UNIFY_ALLOW_DERIVED;
10448 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
10449 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
10451 switch (TREE_CODE (parm))
10453 case TYPENAME_TYPE:
10455 case UNBOUND_CLASS_TEMPLATE:
10456 /* In a type which contains a nested-name-specifier, template
10457 argument values cannot be deduced for template parameters used
10458 within the nested-name-specifier. */
10461 case TEMPLATE_TYPE_PARM:
10462 case TEMPLATE_TEMPLATE_PARM:
10463 case BOUND_TEMPLATE_TEMPLATE_PARM:
10464 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10465 if (tparm == error_mark_node)
10468 if (TEMPLATE_TYPE_LEVEL (parm)
10469 != template_decl_level (tparm))
10470 /* The PARM is not one we're trying to unify. Just check
10471 to see if it matches ARG. */
10472 return (TREE_CODE (arg) == TREE_CODE (parm)
10473 && same_type_p (parm, arg)) ? 0 : 1;
10474 idx = TEMPLATE_TYPE_IDX (parm);
10475 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10476 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
10478 /* Check for mixed types and values. */
10479 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10480 && TREE_CODE (tparm) != TYPE_DECL)
10481 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10482 && TREE_CODE (tparm) != TEMPLATE_DECL))
10485 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10487 /* ARG must be constructed from a template class or a template
10488 template parameter. */
10489 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
10490 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
10494 tree parmvec = TYPE_TI_ARGS (parm);
10495 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
10497 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
10500 /* The resolution to DR150 makes clear that default
10501 arguments for an N-argument may not be used to bind T
10502 to a template template parameter with fewer than N
10503 parameters. It is not safe to permit the binding of
10504 default arguments as an extension, as that may change
10505 the meaning of a conforming program. Consider:
10507 struct Dense { static const unsigned int dim = 1; };
10509 template <template <typename> class View,
10511 void operator+(float, View<Block> const&);
10513 template <typename Block,
10514 unsigned int Dim = Block::dim>
10515 struct Lvalue_proxy { operator float() const; };
10519 Lvalue_proxy<Dense> p;
10524 Here, if Lvalue_proxy is permitted to bind to View, then
10525 the global operator+ will be used; if they are not, the
10526 Lvalue_proxy will be converted to float. */
10527 if (coerce_template_parms (argtmplvec, parmvec,
10528 TYPE_TI_TEMPLATE (parm),
10530 /*require_all_args=*/true,
10531 /*use_default_args=*/false)
10532 == error_mark_node)
10535 /* Deduce arguments T, i from TT<T> or TT<i>.
10536 We check each element of PARMVEC and ARGVEC individually
10537 rather than the whole TREE_VEC since they can have
10538 different number of elements. */
10540 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
10542 if (unify (tparms, targs,
10543 TREE_VEC_ELT (parmvec, i),
10544 TREE_VEC_ELT (argvec, i),
10549 arg = TYPE_TI_TEMPLATE (arg);
10551 /* Fall through to deduce template name. */
10554 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10555 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10557 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
10559 /* Simple cases: Value already set, does match or doesn't. */
10560 if (targ != NULL_TREE && template_args_equal (targ, arg))
10567 /* If PARM is `const T' and ARG is only `int', we don't have
10568 a match unless we are allowing additional qualification.
10569 If ARG is `const int' and PARM is just `T' that's OK;
10570 that binds `const int' to `T'. */
10571 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
10575 /* Consider the case where ARG is `const volatile int' and
10576 PARM is `const T'. Then, T should be `volatile int'. */
10577 arg = cp_build_qualified_type_real
10578 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
10579 if (arg == error_mark_node)
10582 /* Simple cases: Value already set, does match or doesn't. */
10583 if (targ != NULL_TREE && same_type_p (targ, arg))
10588 /* Make sure that ARG is not a variable-sized array. (Note
10589 that were talking about variable-sized arrays (like
10590 `int[n]'), rather than arrays of unknown size (like
10591 `int[]').) We'll get very confused by such a type since
10592 the bound of the array will not be computable in an
10593 instantiation. Besides, such types are not allowed in
10594 ISO C++, so we can do as we please here. */
10595 if (variably_modified_type_p (arg, NULL_TREE))
10599 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10602 case TEMPLATE_PARM_INDEX:
10603 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10604 if (tparm == error_mark_node)
10607 if (TEMPLATE_PARM_LEVEL (parm)
10608 != template_decl_level (tparm))
10609 /* The PARM is not one we're trying to unify. Just check
10610 to see if it matches ARG. */
10611 return !(TREE_CODE (arg) == TREE_CODE (parm)
10612 && cp_tree_equal (parm, arg));
10614 idx = TEMPLATE_PARM_IDX (parm);
10615 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10618 return !cp_tree_equal (targ, arg);
10620 /* [temp.deduct.type] If, in the declaration of a function template
10621 with a non-type template-parameter, the non-type
10622 template-parameter is used in an expression in the function
10623 parameter-list and, if the corresponding template-argument is
10624 deduced, the template-argument type shall match the type of the
10625 template-parameter exactly, except that a template-argument
10626 deduced from an array bound may be of any integral type.
10627 The non-type parameter might use already deduced type parameters. */
10628 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
10629 if (!TREE_TYPE (arg))
10630 /* Template-parameter dependent expression. Just accept it for now.
10631 It will later be processed in convert_template_argument. */
10633 else if (same_type_p (TREE_TYPE (arg), tparm))
10635 else if ((strict & UNIFY_ALLOW_INTEGER)
10636 && (TREE_CODE (tparm) == INTEGER_TYPE
10637 || TREE_CODE (tparm) == BOOLEAN_TYPE))
10638 /* Convert the ARG to the type of PARM; the deduced non-type
10639 template argument must exactly match the types of the
10640 corresponding parameter. */
10641 arg = fold (build_nop (TREE_TYPE (parm), arg));
10642 else if (uses_template_parms (tparm))
10643 /* We haven't deduced the type of this parameter yet. Try again
10649 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10654 /* A pointer-to-member constant can be unified only with
10655 another constant. */
10656 if (TREE_CODE (arg) != PTRMEM_CST)
10659 /* Just unify the class member. It would be useless (and possibly
10660 wrong, depending on the strict flags) to unify also
10661 PTRMEM_CST_CLASS, because we want to be sure that both parm and
10662 arg refer to the same variable, even if through different
10663 classes. For instance:
10665 struct A { int x; };
10668 Unification of &A::x and &B::x must succeed. */
10669 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
10670 PTRMEM_CST_MEMBER (arg), strict);
10675 if (TREE_CODE (arg) != POINTER_TYPE)
10678 /* [temp.deduct.call]
10680 A can be another pointer or pointer to member type that can
10681 be converted to the deduced A via a qualification
10682 conversion (_conv.qual_).
10684 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
10685 This will allow for additional cv-qualification of the
10686 pointed-to types if appropriate. */
10688 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10689 /* The derived-to-base conversion only persists through one
10690 level of pointers. */
10691 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10693 return unify (tparms, targs, TREE_TYPE (parm),
10694 TREE_TYPE (arg), strict);
10697 case REFERENCE_TYPE:
10698 if (TREE_CODE (arg) != REFERENCE_TYPE)
10700 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10701 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10704 if (TREE_CODE (arg) != ARRAY_TYPE)
10706 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10707 != (TYPE_DOMAIN (arg) == NULL_TREE))
10709 if (TYPE_DOMAIN (parm) != NULL_TREE)
10716 /* Our representation of array types uses "N - 1" as the
10717 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
10718 not an integer constant. We cannot unify arbitrarily
10719 complex expressions, so we eliminate the MINUS_EXPRs
10721 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
10722 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
10725 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
10726 parm_max = TREE_OPERAND (parm_max, 0);
10728 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
10729 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
10732 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
10733 trying to unify the type of a variable with the type
10734 of a template parameter. For example:
10736 template <unsigned int N>
10737 void f (char (&) [N]);
10744 Here, the type of the ARG will be "int [g(i)]", and
10745 may be a SAVE_EXPR, etc. */
10746 if (TREE_CODE (arg_max) != MINUS_EXPR)
10748 arg_max = TREE_OPERAND (arg_max, 0);
10751 /* If only one of the bounds used a MINUS_EXPR, compensate
10752 by adding one to the other bound. */
10753 if (parm_cst && !arg_cst)
10754 parm_max = fold_build2 (PLUS_EXPR,
10758 else if (arg_cst && !parm_cst)
10759 arg_max = fold_build2 (PLUS_EXPR,
10764 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
10767 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10768 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10775 case ENUMERAL_TYPE:
10777 if (TREE_CODE (arg) != TREE_CODE (parm))
10780 /* We have already checked cv-qualification at the top of the
10782 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10785 /* As far as unification is concerned, this wins. Later checks
10786 will invalidate it if necessary. */
10789 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10790 /* Type INTEGER_CST can come from ordinary constant template args. */
10792 while (TREE_CODE (arg) == NOP_EXPR)
10793 arg = TREE_OPERAND (arg, 0);
10795 if (TREE_CODE (arg) != INTEGER_CST)
10797 return !tree_int_cst_equal (parm, arg);
10802 if (TREE_CODE (arg) != TREE_VEC)
10804 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10806 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10807 if (unify (tparms, targs,
10808 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10816 if (TREE_CODE (arg) != TREE_CODE (parm))
10819 if (TYPE_PTRMEMFUNC_P (parm))
10821 if (!TYPE_PTRMEMFUNC_P (arg))
10824 return unify (tparms, targs,
10825 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10826 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10830 if (CLASSTYPE_TEMPLATE_INFO (parm))
10832 tree t = NULL_TREE;
10834 if (strict_in & UNIFY_ALLOW_DERIVED)
10836 /* First, we try to unify the PARM and ARG directly. */
10837 t = try_class_unification (tparms, targs,
10842 /* Fallback to the special case allowed in
10843 [temp.deduct.call]:
10845 If P is a class, and P has the form
10846 template-id, then A can be a derived class of
10847 the deduced A. Likewise, if P is a pointer to
10848 a class of the form template-id, A can be a
10849 pointer to a derived class pointed to by the
10851 t = get_template_base (tparms, targs, parm, arg);
10857 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10858 && (CLASSTYPE_TI_TEMPLATE (parm)
10859 == CLASSTYPE_TI_TEMPLATE (arg)))
10860 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10861 Then, we should unify `int' and `U'. */
10864 /* There's no chance of unification succeeding. */
10867 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10868 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10870 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10875 case FUNCTION_TYPE:
10876 if (TREE_CODE (arg) != TREE_CODE (parm))
10879 /* CV qualifications for methods can never be deduced, they must
10880 match exactly. We need to check them explicitly here,
10881 because type_unification_real treats them as any other
10882 cvqualified parameter. */
10883 if (TREE_CODE (parm) == METHOD_TYPE
10884 && (!check_cv_quals_for_unify
10886 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
10887 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
10890 if (unify (tparms, targs, TREE_TYPE (parm),
10891 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10893 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10894 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
10898 /* Unify a pointer to member with a pointer to member function, which
10899 deduces the type of the member as a function type. */
10900 if (TYPE_PTRMEMFUNC_P (arg))
10904 cp_cv_quals cv_quals;
10906 /* Check top-level cv qualifiers */
10907 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
10910 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10911 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
10914 /* Determine the type of the function we are unifying against. */
10915 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
10917 build_function_type (TREE_TYPE (method_type),
10918 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
10920 /* Extract the cv-qualifiers of the member function from the
10921 implicit object parameter and place them on the function
10922 type to be restored later. */
10924 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
10925 fntype = build_qualified_type (fntype, cv_quals);
10926 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
10929 if (TREE_CODE (arg) != OFFSET_TYPE)
10931 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10932 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10934 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10938 if (DECL_TEMPLATE_PARM_P (parm))
10939 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10940 if (arg != integral_constant_value (parm))
10945 case TEMPLATE_DECL:
10946 /* Matched cases are handled by the ARG == PARM test above. */
10950 gcc_assert (EXPR_P (parm));
10952 /* We must be looking at an expression. This can happen with
10956 void foo(S<I>, S<I + 2>);
10958 This is a "nondeduced context":
10962 The nondeduced contexts are:
10964 --A type that is a template-id in which one or more of
10965 the template-arguments is an expression that references
10966 a template-parameter.
10968 In these cases, we assume deduction succeeded, but don't
10969 actually infer any unifications. */
10971 if (!uses_template_parms (parm)
10972 && !template_args_equal (parm, arg))
10979 /* Note that DECL can be defined in this translation unit, if
10983 mark_definable (tree decl)
10986 DECL_NOT_REALLY_EXTERN (decl) = 1;
10987 FOR_EACH_CLONE (clone, decl)
10988 DECL_NOT_REALLY_EXTERN (clone) = 1;
10991 /* Called if RESULT is explicitly instantiated, or is a member of an
10992 explicitly instantiated class. */
10995 mark_decl_instantiated (tree result, int extern_p)
10997 SET_DECL_EXPLICIT_INSTANTIATION (result);
10999 /* If this entity has already been written out, it's too late to
11000 make any modifications. */
11001 if (TREE_ASM_WRITTEN (result))
11004 if (TREE_CODE (result) != FUNCTION_DECL)
11005 /* The TREE_PUBLIC flag for function declarations will have been
11006 set correctly by tsubst. */
11007 TREE_PUBLIC (result) = 1;
11009 /* This might have been set by an earlier implicit instantiation. */
11010 DECL_COMDAT (result) = 0;
11013 DECL_NOT_REALLY_EXTERN (result) = 0;
11016 mark_definable (result);
11017 /* Always make artificials weak. */
11018 if (DECL_ARTIFICIAL (result) && flag_weak)
11019 comdat_linkage (result);
11020 /* For WIN32 we also want to put explicit instantiations in
11021 linkonce sections. */
11022 else if (TREE_PUBLIC (result))
11023 maybe_make_one_only (result);
11026 /* If EXTERN_P, then this function will not be emitted -- unless
11027 followed by an explicit instantiation, at which point its linkage
11028 will be adjusted. If !EXTERN_P, then this function will be
11029 emitted here. In neither circumstance do we want
11030 import_export_decl to adjust the linkage. */
11031 DECL_INTERFACE_KNOWN (result) = 1;
11034 /* Given two function templates PAT1 and PAT2, return:
11036 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
11037 -1 if PAT2 is more specialized than PAT1.
11038 0 if neither is more specialized.
11040 LEN indicates the number of parameters we should consider
11041 (defaulted parameters should not be considered).
11043 The 1998 std underspecified function template partial ordering, and
11044 DR214 addresses the issue. We take pairs of arguments, one from
11045 each of the templates, and deduce them against each other. One of
11046 the templates will be more specialized if all the *other*
11047 template's arguments deduce against its arguments and at least one
11048 of its arguments *does* *not* deduce against the other template's
11049 corresponding argument. Deduction is done as for class templates.
11050 The arguments used in deduction have reference and top level cv
11051 qualifiers removed. Iff both arguments were originally reference
11052 types *and* deduction succeeds in both directions, the template
11053 with the more cv-qualified argument wins for that pairing (if
11054 neither is more cv-qualified, they both are equal). Unlike regular
11055 deduction, after all the arguments have been deduced in this way,
11056 we do *not* verify the deduced template argument values can be
11057 substituted into non-deduced contexts, nor do we have to verify
11058 that all template arguments have been deduced. */
11061 more_specialized_fn (tree pat1, tree pat2, int len)
11063 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
11064 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
11065 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
11066 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
11067 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
11068 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
11069 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
11070 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
11074 /* Remove the this parameter from non-static member functions. If
11075 one is a non-static member function and the other is not a static
11076 member function, remove the first parameter from that function
11077 also. This situation occurs for operator functions where we
11078 locate both a member function (with this pointer) and non-member
11079 operator (with explicit first operand). */
11080 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
11082 len--; /* LEN is the number of significant arguments for DECL1 */
11083 args1 = TREE_CHAIN (args1);
11084 if (!DECL_STATIC_FUNCTION_P (decl2))
11085 args2 = TREE_CHAIN (args2);
11087 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
11089 args2 = TREE_CHAIN (args2);
11090 if (!DECL_STATIC_FUNCTION_P (decl1))
11093 args1 = TREE_CHAIN (args1);
11097 /* If only one is a conversion operator, they are unordered. */
11098 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
11101 /* Consider the return type for a conversion function */
11102 if (DECL_CONV_FN_P (decl1))
11104 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
11105 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
11109 processing_template_decl++;
11113 tree arg1 = TREE_VALUE (args1);
11114 tree arg2 = TREE_VALUE (args2);
11115 int deduce1, deduce2;
11119 if (TREE_CODE (arg1) == REFERENCE_TYPE)
11121 arg1 = TREE_TYPE (arg1);
11122 quals1 = cp_type_quals (arg1);
11125 if (TREE_CODE (arg2) == REFERENCE_TYPE)
11127 arg2 = TREE_TYPE (arg2);
11128 quals2 = cp_type_quals (arg2);
11131 if ((quals1 < 0) != (quals2 < 0))
11133 /* Only of the args is a reference, see if we should apply
11134 array/function pointer decay to it. This is not part of
11135 DR214, but is, IMHO, consistent with the deduction rules
11136 for the function call itself, and with our earlier
11137 implementation of the underspecified partial ordering
11138 rules. (nathan). */
11141 switch (TREE_CODE (arg1))
11144 arg1 = TREE_TYPE (arg1);
11146 case FUNCTION_TYPE:
11147 arg1 = build_pointer_type (arg1);
11156 switch (TREE_CODE (arg2))
11159 arg2 = TREE_TYPE (arg2);
11161 case FUNCTION_TYPE:
11162 arg2 = build_pointer_type (arg2);
11171 arg1 = TYPE_MAIN_VARIANT (arg1);
11172 arg2 = TYPE_MAIN_VARIANT (arg2);
11174 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
11175 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
11181 if (better1 < 0 && better2 < 0)
11182 /* We've failed to deduce something in either direction.
11183 These must be unordered. */
11186 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
11188 /* Deduces in both directions, see if quals can
11189 disambiguate. Pretend the worse one failed to deduce. */
11190 if ((quals1 & quals2) == quals2)
11192 if ((quals1 & quals2) == quals1)
11195 if (deduce1 && !deduce2 && !better2)
11197 if (deduce2 && !deduce1 && !better1)
11200 args1 = TREE_CHAIN (args1);
11201 args2 = TREE_CHAIN (args2);
11204 processing_template_decl--;
11206 return (better1 > 0) - (better2 > 0);
11209 /* Determine which of two partial specializations is more specialized.
11211 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
11212 to the first partial specialization. The TREE_VALUE is the
11213 innermost set of template parameters for the partial
11214 specialization. PAT2 is similar, but for the second template.
11216 Return 1 if the first partial specialization is more specialized;
11217 -1 if the second is more specialized; 0 if neither is more
11220 See [temp.class.order] for information about determining which of
11221 two templates is more specialized. */
11224 more_specialized_class (tree pat1, tree pat2)
11230 tmpl1 = TREE_TYPE (pat1);
11231 tmpl2 = TREE_TYPE (pat2);
11233 /* Just like what happens for functions, if we are ordering between
11234 different class template specializations, we may encounter dependent
11235 types in the arguments, and we need our dependency check functions
11236 to behave correctly. */
11237 ++processing_template_decl;
11238 targs = get_class_bindings (TREE_VALUE (pat1),
11239 CLASSTYPE_TI_ARGS (tmpl1),
11240 CLASSTYPE_TI_ARGS (tmpl2));
11244 targs = get_class_bindings (TREE_VALUE (pat2),
11245 CLASSTYPE_TI_ARGS (tmpl2),
11246 CLASSTYPE_TI_ARGS (tmpl1));
11249 --processing_template_decl;
11254 /* Return the template arguments that will produce the function signature
11255 DECL from the function template FN, with the explicit template
11256 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
11257 also match. Return NULL_TREE if no satisfactory arguments could be
11261 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
11263 int ntparms = DECL_NTPARMS (fn);
11264 tree targs = make_tree_vec (ntparms);
11266 tree decl_arg_types;
11268 /* Substitute the explicit template arguments into the type of DECL.
11269 The call to fn_type_unification will handle substitution into the
11271 decl_type = TREE_TYPE (decl);
11272 if (explicit_args && uses_template_parms (decl_type))
11275 tree converted_args;
11277 if (DECL_TEMPLATE_INFO (decl))
11278 tmpl = DECL_TI_TEMPLATE (decl);
11280 /* We can get here for some invalid specializations. */
11284 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
11285 explicit_args, NULL_TREE,
11287 /*require_all_args=*/false,
11288 /*use_default_args=*/false);
11289 if (converted_args == error_mark_node)
11292 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
11293 if (decl_type == error_mark_node)
11297 /* Never do unification on the 'this' parameter. */
11298 decl_arg_types = skip_artificial_parms_for (decl,
11299 TYPE_ARG_TYPES (decl_type));
11301 if (fn_type_unification (fn, explicit_args, targs,
11303 (check_rettype || DECL_CONV_FN_P (fn)
11304 ? TREE_TYPE (decl_type) : NULL_TREE),
11305 DEDUCE_EXACT, LOOKUP_NORMAL))
11311 /* Return the innermost template arguments that, when applied to a
11312 template specialization whose innermost template parameters are
11313 TPARMS, and whose specialization arguments are PARMS, yield the
11316 For example, suppose we have:
11318 template <class T, class U> struct S {};
11319 template <class T> struct S<T*, int> {};
11321 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
11322 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
11323 int}. The resulting vector will be {double}, indicating that `T'
11324 is bound to `double'. */
11327 get_class_bindings (tree tparms, tree spec_args, tree args)
11329 int i, ntparms = TREE_VEC_LENGTH (tparms);
11331 tree innermost_deduced_args;
11333 innermost_deduced_args = make_tree_vec (ntparms);
11334 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
11336 deduced_args = copy_node (args);
11337 SET_TMPL_ARGS_LEVEL (deduced_args,
11338 TMPL_ARGS_DEPTH (deduced_args),
11339 innermost_deduced_args);
11342 deduced_args = innermost_deduced_args;
11344 if (unify (tparms, deduced_args,
11345 INNERMOST_TEMPLATE_ARGS (spec_args),
11346 INNERMOST_TEMPLATE_ARGS (args),
11350 for (i = 0; i < ntparms; ++i)
11351 if (! TREE_VEC_ELT (innermost_deduced_args, i))
11354 /* Verify that nondeduced template arguments agree with the type
11355 obtained from argument deduction.
11359 struct A { typedef int X; };
11360 template <class T, class U> struct C {};
11361 template <class T> struct C<T, typename T::X> {};
11363 Then with the instantiation `C<A, int>', we can deduce that
11364 `T' is `A' but unify () does not check whether `typename T::X'
11366 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
11367 if (spec_args == error_mark_node
11368 /* We only need to check the innermost arguments; the other
11369 arguments will always agree. */
11370 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
11371 INNERMOST_TEMPLATE_ARGS (args)))
11374 return deduced_args;
11377 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
11378 Return the TREE_LIST node with the most specialized template, if
11379 any. If there is no most specialized template, the error_mark_node
11382 Note that this function does not look at, or modify, the
11383 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
11384 returned is one of the elements of INSTANTIATIONS, callers may
11385 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
11386 and retrieve it from the value returned. */
11389 most_specialized_instantiation (tree templates)
11393 ++processing_template_decl;
11396 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
11400 if (get_bindings (TREE_VALUE (champ),
11401 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11402 NULL_TREE, /*check_ret=*/false))
11405 if (get_bindings (TREE_VALUE (fn),
11406 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11407 NULL_TREE, /*check_ret=*/false))
11414 /* Equally specialized, move to next function. If there
11415 is no next function, nothing's most specialized. */
11416 fn = TREE_CHAIN (fn);
11424 /* Now verify that champ is better than everything earlier in the
11425 instantiation list. */
11426 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
11427 if (get_bindings (TREE_VALUE (champ),
11428 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11429 NULL_TREE, /*check_ret=*/false)
11430 || !get_bindings (TREE_VALUE (fn),
11431 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11432 NULL_TREE, /*check_ret=*/false))
11438 processing_template_decl--;
11441 return error_mark_node;
11446 /* If DECL is a specialization of some template, return the most
11447 general such template. Otherwise, returns NULL_TREE.
11449 For example, given:
11451 template <class T> struct S { template <class U> void f(U); };
11453 if TMPL is `template <class U> void S<int>::f(U)' this will return
11454 the full template. This function will not trace past partial
11455 specializations, however. For example, given in addition:
11457 template <class T> struct S<T*> { template <class U> void f(U); };
11459 if TMPL is `template <class U> void S<int*>::f(U)' this will return
11460 `template <class T> template <class U> S<T*>::f(U)'. */
11463 most_general_template (tree decl)
11465 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
11466 an immediate specialization. */
11467 if (TREE_CODE (decl) == FUNCTION_DECL)
11469 if (DECL_TEMPLATE_INFO (decl)) {
11470 decl = DECL_TI_TEMPLATE (decl);
11472 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
11473 template friend. */
11474 if (TREE_CODE (decl) != TEMPLATE_DECL)
11480 /* Look for more and more general templates. */
11481 while (DECL_TEMPLATE_INFO (decl))
11483 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
11484 (See cp-tree.h for details.) */
11485 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
11488 if (CLASS_TYPE_P (TREE_TYPE (decl))
11489 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
11492 /* Stop if we run into an explicitly specialized class template. */
11493 if (!DECL_NAMESPACE_SCOPE_P (decl)
11494 && DECL_CONTEXT (decl)
11495 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
11498 decl = DECL_TI_TEMPLATE (decl);
11504 /* Return the most specialized of the class template partial
11505 specializations of TMPL which can produce TYPE, a specialization of
11506 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
11507 a _TYPE node corresponding to the partial specialization, while the
11508 TREE_PURPOSE is the set of template arguments that must be
11509 substituted into the TREE_TYPE in order to generate TYPE.
11511 If the choice of partial specialization is ambiguous, a diagnostic
11512 is issued, and the error_mark_node is returned. If there are no
11513 partial specializations of TMPL matching TYPE, then NULL_TREE is
11517 most_specialized_class (tree type, tree tmpl)
11519 tree list = NULL_TREE;
11526 tmpl = most_general_template (tmpl);
11527 args = CLASSTYPE_TI_ARGS (type);
11528 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
11530 tree partial_spec_args;
11533 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
11534 spec_args = get_class_bindings (TREE_VALUE (t),
11539 list = tree_cons (spec_args, TREE_VALUE (t), list);
11540 TREE_TYPE (list) = TREE_TYPE (t);
11547 ambiguous_p = false;
11550 t = TREE_CHAIN (t);
11551 for (; t; t = TREE_CHAIN (t))
11553 fate = more_specialized_class (champ, t);
11560 t = TREE_CHAIN (t);
11563 ambiguous_p = true;
11572 for (t = list; t && t != champ; t = TREE_CHAIN (t))
11574 fate = more_specialized_class (champ, t);
11577 ambiguous_p = true;
11584 const char *str = "candidates are:";
11585 error ("ambiguous class template instantiation for %q#T", type);
11586 for (t = list; t; t = TREE_CHAIN (t))
11588 error ("%s %+#T", str, TREE_TYPE (t));
11591 return error_mark_node;
11597 /* Explicitly instantiate DECL. */
11600 do_decl_instantiation (tree decl, tree storage)
11602 tree result = NULL_TREE;
11605 if (!decl || decl == error_mark_node)
11606 /* An error occurred, for which grokdeclarator has already issued
11607 an appropriate message. */
11609 else if (! DECL_LANG_SPECIFIC (decl))
11611 error ("explicit instantiation of non-template %q#D", decl);
11614 else if (TREE_CODE (decl) == VAR_DECL)
11616 /* There is an asymmetry here in the way VAR_DECLs and
11617 FUNCTION_DECLs are handled by grokdeclarator. In the case of
11618 the latter, the DECL we get back will be marked as a
11619 template instantiation, and the appropriate
11620 DECL_TEMPLATE_INFO will be set up. This does not happen for
11621 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
11622 should handle VAR_DECLs as it currently handles
11624 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
11625 if (!result || TREE_CODE (result) != VAR_DECL)
11627 error ("no matching template for %qD found", decl);
11631 else if (TREE_CODE (decl) != FUNCTION_DECL)
11633 error ("explicit instantiation of %q#D", decl);
11639 /* Check for various error cases. Note that if the explicit
11640 instantiation is valid the RESULT will currently be marked as an
11641 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
11642 until we get here. */
11644 if (DECL_TEMPLATE_SPECIALIZATION (result))
11646 /* DR 259 [temp.spec].
11648 Both an explicit instantiation and a declaration of an explicit
11649 specialization shall not appear in a program unless the explicit
11650 instantiation follows a declaration of the explicit specialization.
11652 For a given set of template parameters, if an explicit
11653 instantiation of a template appears after a declaration of an
11654 explicit specialization for that template, the explicit
11655 instantiation has no effect. */
11658 else if (DECL_EXPLICIT_INSTANTIATION (result))
11662 No program shall explicitly instantiate any template more
11665 We check DECL_NOT_REALLY_EXTERN so as not to complain when
11666 the first instantiation was `extern' and the second is not,
11667 and EXTERN_P for the opposite case. */
11668 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
11669 pedwarn ("duplicate explicit instantiation of %q#D", result);
11670 /* If an "extern" explicit instantiation follows an ordinary
11671 explicit instantiation, the template is instantiated. */
11675 else if (!DECL_IMPLICIT_INSTANTIATION (result))
11677 error ("no matching template for %qD found", result);
11680 else if (!DECL_TEMPLATE_INFO (result))
11682 pedwarn ("explicit instantiation of non-template %q#D", result);
11686 if (storage == NULL_TREE)
11688 else if (storage == ridpointers[(int) RID_EXTERN])
11690 if (pedantic && !in_system_header)
11691 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
11696 error ("storage class %qD applied to template instantiation", storage);
11698 check_explicit_instantiation_namespace (result);
11699 mark_decl_instantiated (result, extern_p);
11701 instantiate_decl (result, /*defer_ok=*/1,
11702 /*expl_inst_class_mem_p=*/false);
11706 mark_class_instantiated (tree t, int extern_p)
11708 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
11709 SET_CLASSTYPE_INTERFACE_KNOWN (t);
11710 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
11711 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
11714 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
11715 rest_of_type_compilation (t, 1);
11719 /* Called from do_type_instantiation through binding_table_foreach to
11720 do recursive instantiation for the type bound in ENTRY. */
11722 bt_instantiate_type_proc (binding_entry entry, void *data)
11724 tree storage = *(tree *) data;
11726 if (IS_AGGR_TYPE (entry->type)
11727 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
11728 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
11731 /* Called from do_type_instantiation to instantiate a member
11732 (a member function or a static member variable) of an
11733 explicitly instantiated class template. */
11735 instantiate_class_member (tree decl, int extern_p)
11737 mark_decl_instantiated (decl, extern_p);
11739 instantiate_decl (decl, /*defer_ok=*/1,
11740 /*expl_inst_class_mem_p=*/true);
11743 /* Perform an explicit instantiation of template class T. STORAGE, if
11744 non-null, is the RID for extern, inline or static. COMPLAIN is
11745 nonzero if this is called from the parser, zero if called recursively,
11746 since the standard is unclear (as detailed below). */
11749 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
11754 int previous_instantiation_extern_p = 0;
11756 if (TREE_CODE (t) == TYPE_DECL)
11759 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
11761 error ("explicit instantiation of non-template type %qT", t);
11767 if (!COMPLETE_TYPE_P (t))
11769 if (complain & tf_error)
11770 error ("explicit instantiation of %q#T before definition of template",
11775 if (storage != NULL_TREE)
11777 if (pedantic && !in_system_header)
11778 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
11781 if (storage == ridpointers[(int) RID_INLINE])
11783 else if (storage == ridpointers[(int) RID_EXTERN])
11785 else if (storage == ridpointers[(int) RID_STATIC])
11789 error ("storage class %qD applied to template instantiation",
11795 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
11797 /* DR 259 [temp.spec].
11799 Both an explicit instantiation and a declaration of an explicit
11800 specialization shall not appear in a program unless the explicit
11801 instantiation follows a declaration of the explicit specialization.
11803 For a given set of template parameters, if an explicit
11804 instantiation of a template appears after a declaration of an
11805 explicit specialization for that template, the explicit
11806 instantiation has no effect. */
11809 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
11813 No program shall explicitly instantiate any template more
11816 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
11817 instantiation was `extern'. If EXTERN_P then the second is.
11818 These cases are OK. */
11819 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
11821 if (!previous_instantiation_extern_p && !extern_p
11822 && (complain & tf_error))
11823 pedwarn ("duplicate explicit instantiation of %q#T", t);
11825 /* If we've already instantiated the template, just return now. */
11826 if (!CLASSTYPE_INTERFACE_ONLY (t))
11830 check_explicit_instantiation_namespace (TYPE_NAME (t));
11831 mark_class_instantiated (t, extern_p);
11839 /* In contrast to implicit instantiation, where only the
11840 declarations, and not the definitions, of members are
11841 instantiated, we have here:
11845 The explicit instantiation of a class template specialization
11846 implies the instantiation of all of its members not
11847 previously explicitly specialized in the translation unit
11848 containing the explicit instantiation.
11850 Of course, we can't instantiate member template classes, since
11851 we don't have any arguments for them. Note that the standard
11852 is unclear on whether the instantiation of the members are
11853 *explicit* instantiations or not. However, the most natural
11854 interpretation is that it should be an explicit instantiation. */
11857 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
11858 if (TREE_CODE (tmp) == FUNCTION_DECL
11859 && DECL_TEMPLATE_INSTANTIATION (tmp))
11860 instantiate_class_member (tmp, extern_p);
11862 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
11863 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
11864 instantiate_class_member (tmp, extern_p);
11866 if (CLASSTYPE_NESTED_UTDS (t))
11867 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
11868 bt_instantiate_type_proc, &storage);
11872 /* Given a function DECL, which is a specialization of TMPL, modify
11873 DECL to be a re-instantiation of TMPL with the same template
11874 arguments. TMPL should be the template into which tsubst'ing
11875 should occur for DECL, not the most general template.
11877 One reason for doing this is a scenario like this:
11880 void f(const T&, int i);
11882 void g() { f(3, 7); }
11885 void f(const T& t, const int i) { }
11887 Note that when the template is first instantiated, with
11888 instantiate_template, the resulting DECL will have no name for the
11889 first parameter, and the wrong type for the second. So, when we go
11890 to instantiate the DECL, we regenerate it. */
11893 regenerate_decl_from_template (tree decl, tree tmpl)
11895 /* The arguments used to instantiate DECL, from the most general
11900 args = DECL_TI_ARGS (decl);
11901 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
11903 /* Make sure that we can see identifiers, and compute access
11905 push_access_scope (decl);
11907 if (TREE_CODE (decl) == FUNCTION_DECL)
11915 args_depth = TMPL_ARGS_DEPTH (args);
11916 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
11917 if (args_depth > parms_depth)
11918 args = get_innermost_template_args (args, parms_depth);
11920 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
11921 args, tf_error, NULL_TREE);
11923 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
11926 /* Merge parameter declarations. */
11927 decl_parm = skip_artificial_parms_for (decl,
11928 DECL_ARGUMENTS (decl));
11930 = skip_artificial_parms_for (code_pattern,
11931 DECL_ARGUMENTS (code_pattern));
11937 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
11938 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
11939 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
11941 parm_type = type_decays_to (parm_type);
11942 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
11943 TREE_TYPE (decl_parm) = parm_type;
11944 attributes = DECL_ATTRIBUTES (pattern_parm);
11945 if (DECL_ATTRIBUTES (decl_parm) != attributes)
11947 DECL_ATTRIBUTES (decl_parm) = attributes;
11948 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
11950 decl_parm = TREE_CHAIN (decl_parm);
11951 pattern_parm = TREE_CHAIN (pattern_parm);
11954 /* Merge additional specifiers from the CODE_PATTERN. */
11955 if (DECL_DECLARED_INLINE_P (code_pattern)
11956 && !DECL_DECLARED_INLINE_P (decl))
11957 DECL_DECLARED_INLINE_P (decl) = 1;
11958 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
11959 DECL_INLINE (decl) = 1;
11961 else if (TREE_CODE (decl) == VAR_DECL)
11962 DECL_INITIAL (decl) =
11963 tsubst_expr (DECL_INITIAL (code_pattern), args,
11964 tf_error, DECL_TI_TEMPLATE (decl),
11965 /*integral_constant_expression_p=*/false);
11967 gcc_unreachable ();
11969 pop_access_scope (decl);
11972 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
11973 substituted to get DECL. */
11976 template_for_substitution (tree decl)
11978 tree tmpl = DECL_TI_TEMPLATE (decl);
11980 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
11981 for the instantiation. This is not always the most general
11982 template. Consider, for example:
11985 struct S { template <class U> void f();
11986 template <> void f<int>(); };
11988 and an instantiation of S<double>::f<int>. We want TD to be the
11989 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11990 while (/* An instantiation cannot have a definition, so we need a
11991 more general template. */
11992 DECL_TEMPLATE_INSTANTIATION (tmpl)
11993 /* We must also deal with friend templates. Given:
11995 template <class T> struct S {
11996 template <class U> friend void f() {};
11999 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
12000 so far as the language is concerned, but that's still
12001 where we get the pattern for the instantiation from. On
12002 other hand, if the definition comes outside the class, say:
12004 template <class T> struct S {
12005 template <class U> friend void f();
12007 template <class U> friend void f() {}
12009 we don't need to look any further. That's what the check for
12010 DECL_INITIAL is for. */
12011 || (TREE_CODE (decl) == FUNCTION_DECL
12012 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
12013 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
12015 /* The present template, TD, should not be a definition. If it
12016 were a definition, we should be using it! Note that we
12017 cannot restructure the loop to just keep going until we find
12018 a template with a definition, since that might go too far if
12019 a specialization was declared, but not defined. */
12020 gcc_assert (TREE_CODE (decl) != VAR_DECL
12021 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
12023 /* Fetch the more general template. */
12024 tmpl = DECL_TI_TEMPLATE (tmpl);
12030 /* Produce the definition of D, a _DECL generated from a template. If
12031 DEFER_OK is nonzero, then we don't have to actually do the
12032 instantiation now; we just have to do it sometime. Normally it is
12033 an error if this is an explicit instantiation but D is undefined.
12034 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
12035 explicitly instantiated class template. */
12038 instantiate_decl (tree d, int defer_ok,
12039 bool expl_inst_class_mem_p)
12041 tree tmpl = DECL_TI_TEMPLATE (d);
12048 bool pattern_defined;
12050 location_t saved_loc = input_location;
12051 int saved_in_system_header = in_system_header;
12054 /* This function should only be used to instantiate templates for
12055 functions and static member variables. */
12056 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
12057 || TREE_CODE (d) == VAR_DECL);
12059 /* Variables are never deferred; if instantiation is required, they
12060 are instantiated right away. That allows for better code in the
12061 case that an expression refers to the value of the variable --
12062 if the variable has a constant value the referring expression can
12063 take advantage of that fact. */
12064 if (TREE_CODE (d) == VAR_DECL)
12067 /* Don't instantiate cloned functions. Instead, instantiate the
12068 functions they cloned. */
12069 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
12070 d = DECL_CLONED_FUNCTION (d);
12072 if (DECL_TEMPLATE_INSTANTIATED (d))
12073 /* D has already been instantiated. It might seem reasonable to
12074 check whether or not D is an explicit instantiation, and, if so,
12075 stop here. But when an explicit instantiation is deferred
12076 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
12077 is set, even though we still need to do the instantiation. */
12080 /* If we already have a specialization of this declaration, then
12081 there's no reason to instantiate it. Note that
12082 retrieve_specialization gives us both instantiations and
12083 specializations, so we must explicitly check
12084 DECL_TEMPLATE_SPECIALIZATION. */
12085 gen_tmpl = most_general_template (tmpl);
12086 gen_args = DECL_TI_ARGS (d);
12087 spec = retrieve_specialization (gen_tmpl, gen_args,
12088 /*class_specializations_p=*/false);
12089 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
12092 /* This needs to happen before any tsubsting. */
12093 if (! push_tinst_level (d))
12096 timevar_push (TV_PARSE);
12098 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
12099 for the instantiation. */
12100 td = template_for_substitution (d);
12101 code_pattern = DECL_TEMPLATE_RESULT (td);
12103 /* We should never be trying to instantiate a member of a class
12104 template or partial specialization. */
12105 gcc_assert (d != code_pattern);
12107 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
12108 || DECL_TEMPLATE_SPECIALIZATION (td))
12109 /* In the case of a friend template whose definition is provided
12110 outside the class, we may have too many arguments. Drop the
12111 ones we don't need. The same is true for specializations. */
12112 args = get_innermost_template_args
12113 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
12117 if (TREE_CODE (d) == FUNCTION_DECL)
12118 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
12120 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
12122 /* We may be in the middle of deferred access check. Disable it now. */
12123 push_deferring_access_checks (dk_no_deferred);
12125 /* Unless an explicit instantiation directive has already determined
12126 the linkage of D, remember that a definition is available for
12128 if (pattern_defined
12129 && !DECL_INTERFACE_KNOWN (d)
12130 && !DECL_NOT_REALLY_EXTERN (d))
12131 mark_definable (d);
12133 input_location = DECL_SOURCE_LOCATION (d);
12134 in_system_header = DECL_IN_SYSTEM_HEADER (d);
12136 /* If D is a member of an explicitly instantiated class template,
12137 and no definition is available, treat it like an implicit
12139 if (!pattern_defined && expl_inst_class_mem_p
12140 && DECL_EXPLICIT_INSTANTIATION (d))
12142 DECL_NOT_REALLY_EXTERN (d) = 0;
12143 DECL_INTERFACE_KNOWN (d) = 0;
12144 SET_DECL_IMPLICIT_INSTANTIATION (d);
12149 /* Recheck the substitutions to obtain any warning messages
12150 about ignoring cv qualifiers. */
12151 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
12152 tree type = TREE_TYPE (gen);
12154 /* Make sure that we can see identifiers, and compute access
12155 correctly. D is already the target FUNCTION_DECL with the
12157 push_access_scope (d);
12159 if (TREE_CODE (gen) == FUNCTION_DECL)
12161 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
12162 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
12163 tf_warning_or_error, d);
12164 /* Don't simply tsubst the function type, as that will give
12165 duplicate warnings about poor parameter qualifications.
12166 The function arguments are the same as the decl_arguments
12167 without the top level cv qualifiers. */
12168 type = TREE_TYPE (type);
12170 tsubst (type, gen_args, tf_warning_or_error, d);
12172 pop_access_scope (d);
12175 /* Check to see whether we know that this template will be
12176 instantiated in some other file, as with "extern template"
12178 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
12179 /* In general, we do not instantiate such templates... */
12181 /* ... but we instantiate inline functions so that we can inline
12183 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
12184 /* ... we instantiate static data members whose values are
12185 needed in integral constant expressions. */
12186 && ! (TREE_CODE (d) == VAR_DECL
12187 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
12189 /* Defer all other templates, unless we have been explicitly
12190 forbidden from doing so. */
12191 if (/* If there is no definition, we cannot instantiate the
12194 /* If it's OK to postpone instantiation, do so. */
12196 /* If this is a static data member that will be defined
12197 elsewhere, we don't want to instantiate the entire data
12198 member, but we do want to instantiate the initializer so that
12199 we can substitute that elsewhere. */
12200 || (external_p && TREE_CODE (d) == VAR_DECL))
12202 /* The definition of the static data member is now required so
12203 we must substitute the initializer. */
12204 if (TREE_CODE (d) == VAR_DECL
12205 && !DECL_INITIAL (d)
12206 && DECL_INITIAL (code_pattern))
12211 ns = decl_namespace_context (d);
12212 push_nested_namespace (ns);
12213 push_nested_class (DECL_CONTEXT (d));
12214 init = tsubst_expr (DECL_INITIAL (code_pattern),
12216 tf_warning_or_error, NULL_TREE,
12217 /*integral_constant_expression_p=*/false);
12218 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
12219 /*asmspec_tree=*/NULL_TREE,
12220 LOOKUP_ONLYCONVERTING);
12221 pop_nested_class ();
12222 pop_nested_namespace (ns);
12225 /* We restore the source position here because it's used by
12226 add_pending_template. */
12227 input_location = saved_loc;
12229 if (at_eof && !pattern_defined
12230 && DECL_EXPLICIT_INSTANTIATION (d))
12233 The definition of a non-exported function template, a
12234 non-exported member function template, or a non-exported
12235 member function or static data member of a class template
12236 shall be present in every translation unit in which it is
12237 explicitly instantiated. */
12239 ("explicit instantiation of %qD but no definition available", d);
12241 /* ??? Historically, we have instantiated inline functions, even
12242 when marked as "extern template". */
12243 if (!(external_p && TREE_CODE (d) == VAR_DECL))
12244 add_pending_template (d);
12247 /* Tell the repository that D is available in this translation unit
12248 -- and see if it is supposed to be instantiated here. */
12249 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
12251 /* In a PCH file, despite the fact that the repository hasn't
12252 requested instantiation in the PCH it is still possible that
12253 an instantiation will be required in a file that includes the
12256 add_pending_template (d);
12257 /* Instantiate inline functions so that the inliner can do its
12258 job, even though we'll not be emitting a copy of this
12260 if (!(TREE_CODE (d) == FUNCTION_DECL
12261 && flag_inline_trees
12262 && DECL_DECLARED_INLINE_P (d)))
12266 need_push = !cfun || !global_bindings_p ();
12268 push_to_top_level ();
12270 /* Mark D as instantiated so that recursive calls to
12271 instantiate_decl do not try to instantiate it again. */
12272 DECL_TEMPLATE_INSTANTIATED (d) = 1;
12274 /* Regenerate the declaration in case the template has been modified
12275 by a subsequent redeclaration. */
12276 regenerate_decl_from_template (d, td);
12278 /* We already set the file and line above. Reset them now in case
12279 they changed as a result of calling regenerate_decl_from_template. */
12280 input_location = DECL_SOURCE_LOCATION (d);
12282 if (TREE_CODE (d) == VAR_DECL)
12286 /* Clear out DECL_RTL; whatever was there before may not be right
12287 since we've reset the type of the declaration. */
12288 SET_DECL_RTL (d, NULL_RTX);
12289 DECL_IN_AGGR_P (d) = 0;
12291 /* The initializer is placed in DECL_INITIAL by
12292 regenerate_decl_from_template. Pull it out so that
12293 finish_decl can process it. */
12294 init = DECL_INITIAL (d);
12295 DECL_INITIAL (d) = NULL_TREE;
12296 DECL_INITIALIZED_P (d) = 0;
12298 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
12299 initializer. That function will defer actual emission until
12300 we have a chance to determine linkage. */
12301 DECL_EXTERNAL (d) = 0;
12303 /* Enter the scope of D so that access-checking works correctly. */
12304 push_nested_class (DECL_CONTEXT (d));
12305 finish_decl (d, init, NULL_TREE);
12306 pop_nested_class ();
12308 else if (TREE_CODE (d) == FUNCTION_DECL)
12310 htab_t saved_local_specializations;
12315 /* Save away the current list, in case we are instantiating one
12316 template from within the body of another. */
12317 saved_local_specializations = local_specializations;
12319 /* Set up the list of local specializations. */
12320 local_specializations = htab_create (37,
12321 hash_local_specialization,
12322 eq_local_specializations,
12325 /* Set up context. */
12326 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
12328 /* Create substitution entries for the parameters. */
12329 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
12330 tmpl_parm = DECL_ARGUMENTS (subst_decl);
12331 spec_parm = DECL_ARGUMENTS (d);
12332 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
12334 register_local_specialization (spec_parm, tmpl_parm);
12335 spec_parm = skip_artificial_parms_for (d, spec_parm);
12336 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
12340 register_local_specialization (spec_parm, tmpl_parm);
12341 tmpl_parm = TREE_CHAIN (tmpl_parm);
12342 spec_parm = TREE_CHAIN (spec_parm);
12344 gcc_assert (!spec_parm);
12346 /* Substitute into the body of the function. */
12347 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
12348 tf_warning_or_error, tmpl,
12349 /*integral_constant_expression_p=*/false);
12351 /* We don't need the local specializations any more. */
12352 htab_delete (local_specializations);
12353 local_specializations = saved_local_specializations;
12355 /* Finish the function. */
12356 d = finish_function (0);
12357 expand_or_defer_fn (d);
12360 /* We're not deferring instantiation any more. */
12361 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
12364 pop_from_top_level ();
12367 input_location = saved_loc;
12368 in_system_header = saved_in_system_header;
12369 pop_deferring_access_checks ();
12370 pop_tinst_level ();
12372 timevar_pop (TV_PARSE);
12377 /* Run through the list of templates that we wish we could
12378 instantiate, and instantiate any we can. RETRIES is the
12379 number of times we retry pending template instantiation. */
12382 instantiate_pending_templates (int retries)
12385 tree last = NULL_TREE;
12387 location_t saved_loc = input_location;
12388 int saved_in_system_header = in_system_header;
12390 /* Instantiating templates may trigger vtable generation. This in turn
12391 may require further template instantiations. We place a limit here
12392 to avoid infinite loop. */
12393 if (pending_templates && retries >= max_tinst_depth)
12395 tree decl = TREE_VALUE (pending_templates);
12397 error ("template instantiation depth exceeds maximum of %d"
12398 " instantiating %q+D, possibly from virtual table generation"
12399 " (use -ftemplate-depth-NN to increase the maximum)",
12400 max_tinst_depth, decl);
12401 if (TREE_CODE (decl) == FUNCTION_DECL)
12402 /* Pretend that we defined it. */
12403 DECL_INITIAL (decl) = error_mark_node;
12411 t = &pending_templates;
12414 tree instantiation = TREE_VALUE (*t);
12416 reopen_tinst_level (TREE_PURPOSE (*t));
12418 if (TYPE_P (instantiation))
12422 if (!COMPLETE_TYPE_P (instantiation))
12424 instantiate_class_template (instantiation);
12425 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
12426 for (fn = TYPE_METHODS (instantiation);
12428 fn = TREE_CHAIN (fn))
12429 if (! DECL_ARTIFICIAL (fn))
12430 instantiate_decl (fn,
12432 /*expl_inst_class_mem_p=*/false);
12433 if (COMPLETE_TYPE_P (instantiation))
12437 if (COMPLETE_TYPE_P (instantiation))
12438 /* If INSTANTIATION has been instantiated, then we don't
12439 need to consider it again in the future. */
12440 *t = TREE_CHAIN (*t);
12444 t = &TREE_CHAIN (*t);
12449 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
12450 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
12453 = instantiate_decl (instantiation,
12455 /*expl_inst_class_mem_p=*/false);
12456 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
12460 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
12461 || DECL_TEMPLATE_INSTANTIATED (instantiation))
12462 /* If INSTANTIATION has been instantiated, then we don't
12463 need to consider it again in the future. */
12464 *t = TREE_CHAIN (*t);
12468 t = &TREE_CHAIN (*t);
12472 current_tinst_level = NULL_TREE;
12474 last_pending_template = last;
12476 while (reconsider);
12478 input_location = saved_loc;
12479 in_system_header = saved_in_system_header;
12482 /* Substitute ARGVEC into T, which is a list of initializers for
12483 either base class or a non-static data member. The TREE_PURPOSEs
12484 are DECLs, and the TREE_VALUEs are the initializer values. Used by
12485 instantiate_decl. */
12488 tsubst_initializer_list (tree t, tree argvec)
12490 tree inits = NULL_TREE;
12492 for (; t; t = TREE_CHAIN (t))
12497 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_warning_or_error,
12499 decl = expand_member_init (decl);
12500 if (decl && !DECL_P (decl))
12501 in_base_initializer = 1;
12503 init = tsubst_expr (TREE_VALUE (t), argvec, tf_warning_or_error,
12505 /*integral_constant_expression_p=*/false);
12506 in_base_initializer = 0;
12510 init = build_tree_list (decl, init);
12511 TREE_CHAIN (init) = inits;
12518 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
12521 set_current_access_from_decl (tree decl)
12523 if (TREE_PRIVATE (decl))
12524 current_access_specifier = access_private_node;
12525 else if (TREE_PROTECTED (decl))
12526 current_access_specifier = access_protected_node;
12528 current_access_specifier = access_public_node;
12531 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
12532 is the instantiation (which should have been created with
12533 start_enum) and ARGS are the template arguments to use. */
12536 tsubst_enum (tree tag, tree newtag, tree args)
12540 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
12545 decl = TREE_VALUE (e);
12546 /* Note that in a template enum, the TREE_VALUE is the
12547 CONST_DECL, not the corresponding INTEGER_CST. */
12548 value = tsubst_expr (DECL_INITIAL (decl),
12549 args, tf_warning_or_error, NULL_TREE,
12550 /*integral_constant_expression_p=*/true);
12552 /* Give this enumeration constant the correct access. */
12553 set_current_access_from_decl (decl);
12555 /* Actually build the enumerator itself. */
12556 build_enumerator (DECL_NAME (decl), value, newtag);
12559 finish_enum (newtag);
12560 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
12561 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
12564 /* DECL is a FUNCTION_DECL that is a template specialization. Return
12565 its type -- but without substituting the innermost set of template
12566 arguments. So, innermost set of template parameters will appear in
12570 get_mostly_instantiated_function_type (tree decl)
12578 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
12579 targs = DECL_TI_ARGS (decl);
12580 tparms = DECL_TEMPLATE_PARMS (tmpl);
12581 parm_depth = TMPL_PARMS_DEPTH (tparms);
12583 /* There should be as many levels of arguments as there are levels
12585 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
12587 fn_type = TREE_TYPE (tmpl);
12589 if (parm_depth == 1)
12590 /* No substitution is necessary. */
12594 int i, save_access_control;
12597 /* Replace the innermost level of the TARGS with NULL_TREEs to
12598 let tsubst know not to substitute for those parameters. */
12599 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
12600 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
12601 SET_TMPL_ARGS_LEVEL (partial_args, i,
12602 TMPL_ARGS_LEVEL (targs, i));
12603 SET_TMPL_ARGS_LEVEL (partial_args,
12604 TMPL_ARGS_DEPTH (targs),
12605 make_tree_vec (DECL_NTPARMS (tmpl)));
12607 /* Disable access control as this function is used only during
12609 save_access_control = flag_access_control;
12610 flag_access_control = 0;
12612 ++processing_template_decl;
12613 /* Now, do the (partial) substitution to figure out the
12614 appropriate function type. */
12615 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
12616 --processing_template_decl;
12618 /* Substitute into the template parameters to obtain the real
12619 innermost set of parameters. This step is important if the
12620 innermost set of template parameters contains value
12621 parameters whose types depend on outer template parameters. */
12622 TREE_VEC_LENGTH (partial_args)--;
12623 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
12625 flag_access_control = save_access_control;
12631 /* Return truthvalue if we're processing a template different from
12632 the last one involved in diagnostics. */
12634 problematic_instantiation_changed (void)
12636 return last_template_error_tick != tinst_level_tick;
12639 /* Remember current template involved in diagnostics. */
12641 record_last_problematic_instantiation (void)
12643 last_template_error_tick = tinst_level_tick;
12647 current_instantiation (void)
12649 return current_tinst_level;
12652 /* [temp.param] Check that template non-type parm TYPE is of an allowable
12653 type. Return zero for ok, nonzero for disallowed. Issue error and
12654 warning messages under control of COMPLAIN. */
12657 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
12659 if (INTEGRAL_TYPE_P (type))
12661 else if (POINTER_TYPE_P (type))
12663 else if (TYPE_PTR_TO_MEMBER_P (type))
12665 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
12667 else if (TREE_CODE (type) == TYPENAME_TYPE)
12670 if (complain & tf_error)
12671 error ("%q#T is not a valid type for a template constant parameter", type);
12675 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
12676 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
12679 dependent_type_p_r (tree type)
12685 A type is dependent if it is:
12687 -- a template parameter. Template template parameters are types
12688 for us (since TYPE_P holds true for them) so we handle
12690 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
12691 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
12693 /* -- a qualified-id with a nested-name-specifier which contains a
12694 class-name that names a dependent type or whose unqualified-id
12695 names a dependent type. */
12696 if (TREE_CODE (type) == TYPENAME_TYPE)
12698 /* -- a cv-qualified type where the cv-unqualified type is
12700 type = TYPE_MAIN_VARIANT (type);
12701 /* -- a compound type constructed from any dependent type. */
12702 if (TYPE_PTR_TO_MEMBER_P (type))
12703 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
12704 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
12706 else if (TREE_CODE (type) == POINTER_TYPE
12707 || TREE_CODE (type) == REFERENCE_TYPE)
12708 return dependent_type_p (TREE_TYPE (type));
12709 else if (TREE_CODE (type) == FUNCTION_TYPE
12710 || TREE_CODE (type) == METHOD_TYPE)
12714 if (dependent_type_p (TREE_TYPE (type)))
12716 for (arg_type = TYPE_ARG_TYPES (type);
12718 arg_type = TREE_CHAIN (arg_type))
12719 if (dependent_type_p (TREE_VALUE (arg_type)))
12723 /* -- an array type constructed from any dependent type or whose
12724 size is specified by a constant expression that is
12725 value-dependent. */
12726 if (TREE_CODE (type) == ARRAY_TYPE)
12728 if (TYPE_DOMAIN (type)
12729 && ((value_dependent_expression_p
12730 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12731 || (type_dependent_expression_p
12732 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
12734 return dependent_type_p (TREE_TYPE (type));
12737 /* -- a template-id in which either the template name is a template
12739 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
12741 /* ... or any of the template arguments is a dependent type or
12742 an expression that is type-dependent or value-dependent. */
12743 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
12744 && (any_dependent_template_arguments_p
12745 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
12748 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
12749 expression is not type-dependent, then it should already been
12751 if (TREE_CODE (type) == TYPEOF_TYPE)
12754 /* The standard does not specifically mention types that are local
12755 to template functions or local classes, but they should be
12756 considered dependent too. For example:
12758 template <int I> void f() {
12763 The size of `E' cannot be known until the value of `I' has been
12764 determined. Therefore, `E' must be considered dependent. */
12765 scope = TYPE_CONTEXT (type);
12766 if (scope && TYPE_P (scope))
12767 return dependent_type_p (scope);
12768 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12769 return type_dependent_expression_p (scope);
12771 /* Other types are non-dependent. */
12775 /* Returns TRUE if TYPE is dependent, in the sense of
12776 [temp.dep.type]. */
12779 dependent_type_p (tree type)
12781 /* If there are no template parameters in scope, then there can't be
12782 any dependent types. */
12783 if (!processing_template_decl)
12785 /* If we are not processing a template, then nobody should be
12786 providing us with a dependent type. */
12788 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
12792 /* If the type is NULL, we have not computed a type for the entity
12793 in question; in that case, the type is dependent. */
12797 /* Erroneous types can be considered non-dependent. */
12798 if (type == error_mark_node)
12801 /* If we have not already computed the appropriate value for TYPE,
12803 if (!TYPE_DEPENDENT_P_VALID (type))
12805 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
12806 TYPE_DEPENDENT_P_VALID (type) = 1;
12809 return TYPE_DEPENDENT_P (type);
12812 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
12815 dependent_scope_ref_p (tree expression, bool criterion (tree))
12820 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
12822 if (!TYPE_P (TREE_OPERAND (expression, 0)))
12825 scope = TREE_OPERAND (expression, 0);
12826 name = TREE_OPERAND (expression, 1);
12830 An id-expression is type-dependent if it contains a
12831 nested-name-specifier that contains a class-name that names a
12833 /* The suggested resolution to Core Issue 2 implies that if the
12834 qualifying type is the current class, then we must peek
12837 && currently_open_class (scope)
12838 && !criterion (name))
12840 if (dependent_type_p (scope))
12846 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
12847 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
12851 value_dependent_expression_p (tree expression)
12853 if (!processing_template_decl)
12856 /* A name declared with a dependent type. */
12857 if (DECL_P (expression) && type_dependent_expression_p (expression))
12860 switch (TREE_CODE (expression))
12862 case IDENTIFIER_NODE:
12863 /* A name that has not been looked up -- must be dependent. */
12866 case TEMPLATE_PARM_INDEX:
12867 /* A non-type template parm. */
12871 /* A non-type template parm. */
12872 if (DECL_TEMPLATE_PARM_P (expression))
12877 /* A constant with integral or enumeration type and is initialized
12878 with an expression that is value-dependent. */
12879 if (DECL_INITIAL (expression)
12880 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
12881 && value_dependent_expression_p (DECL_INITIAL (expression)))
12885 case DYNAMIC_CAST_EXPR:
12886 case STATIC_CAST_EXPR:
12887 case CONST_CAST_EXPR:
12888 case REINTERPRET_CAST_EXPR:
12890 /* These expressions are value-dependent if the type to which
12891 the cast occurs is dependent or the expression being casted
12892 is value-dependent. */
12894 tree type = TREE_TYPE (expression);
12896 if (dependent_type_p (type))
12899 /* A functional cast has a list of operands. */
12900 expression = TREE_OPERAND (expression, 0);
12903 /* If there are no operands, it must be an expression such
12904 as "int()". This should not happen for aggregate types
12905 because it would form non-constant expressions. */
12906 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
12911 if (TREE_CODE (expression) == TREE_LIST)
12912 return any_value_dependent_elements_p (expression);
12914 return value_dependent_expression_p (expression);
12919 /* A `sizeof' expression is value-dependent if the operand is
12921 expression = TREE_OPERAND (expression, 0);
12922 if (TYPE_P (expression))
12923 return dependent_type_p (expression);
12924 return type_dependent_expression_p (expression);
12927 return dependent_scope_ref_p (expression, value_dependent_expression_p);
12929 case COMPONENT_REF:
12930 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
12931 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
12934 /* A CALL_EXPR may appear in a constant expression if it is a
12935 call to a builtin function, e.g., __builtin_constant_p. All
12936 such calls are value-dependent. */
12940 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
12941 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
12944 /* A constant expression is value-dependent if any subexpression is
12945 value-dependent. */
12946 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
12948 case tcc_reference:
12950 return (value_dependent_expression_p
12951 (TREE_OPERAND (expression, 0)));
12953 case tcc_comparison:
12955 return ((value_dependent_expression_p
12956 (TREE_OPERAND (expression, 0)))
12957 || (value_dependent_expression_p
12958 (TREE_OPERAND (expression, 1))));
12960 case tcc_expression:
12963 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
12964 /* In some cases, some of the operands may be missing.
12965 (For example, in the case of PREDECREMENT_EXPR, the
12966 amount to increment by may be missing.) That doesn't
12967 make the expression dependent. */
12968 if (TREE_OPERAND (expression, i)
12969 && (value_dependent_expression_p
12970 (TREE_OPERAND (expression, i))))
12980 /* The expression is not value-dependent. */
12984 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
12985 [temp.dep.expr]. */
12988 type_dependent_expression_p (tree expression)
12990 if (!processing_template_decl)
12993 if (expression == error_mark_node)
12996 /* An unresolved name is always dependent. */
12997 if (TREE_CODE (expression) == IDENTIFIER_NODE
12998 || TREE_CODE (expression) == USING_DECL)
13001 /* Some expression forms are never type-dependent. */
13002 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
13003 || TREE_CODE (expression) == SIZEOF_EXPR
13004 || TREE_CODE (expression) == ALIGNOF_EXPR
13005 || TREE_CODE (expression) == TYPEID_EXPR
13006 || TREE_CODE (expression) == DELETE_EXPR
13007 || TREE_CODE (expression) == VEC_DELETE_EXPR
13008 || TREE_CODE (expression) == THROW_EXPR)
13011 /* The types of these expressions depends only on the type to which
13012 the cast occurs. */
13013 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
13014 || TREE_CODE (expression) == STATIC_CAST_EXPR
13015 || TREE_CODE (expression) == CONST_CAST_EXPR
13016 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
13017 || TREE_CODE (expression) == CAST_EXPR)
13018 return dependent_type_p (TREE_TYPE (expression));
13020 /* The types of these expressions depends only on the type created
13021 by the expression. */
13022 if (TREE_CODE (expression) == NEW_EXPR
13023 || TREE_CODE (expression) == VEC_NEW_EXPR)
13025 /* For NEW_EXPR tree nodes created inside a template, either
13026 the object type itself or a TREE_LIST may appear as the
13028 tree type = TREE_OPERAND (expression, 1);
13029 if (TREE_CODE (type) == TREE_LIST)
13030 /* This is an array type. We need to check array dimensions
13032 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
13033 || value_dependent_expression_p
13034 (TREE_OPERAND (TREE_VALUE (type), 1));
13036 return dependent_type_p (type);
13039 if (TREE_CODE (expression) == SCOPE_REF
13040 && dependent_scope_ref_p (expression,
13041 type_dependent_expression_p))
13044 if (TREE_CODE (expression) == FUNCTION_DECL
13045 && DECL_LANG_SPECIFIC (expression)
13046 && DECL_TEMPLATE_INFO (expression)
13047 && (any_dependent_template_arguments_p
13048 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
13051 if (TREE_CODE (expression) == TEMPLATE_DECL
13052 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
13055 if (TREE_TYPE (expression) == unknown_type_node)
13057 if (TREE_CODE (expression) == ADDR_EXPR)
13058 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
13059 if (TREE_CODE (expression) == COMPONENT_REF
13060 || TREE_CODE (expression) == OFFSET_REF)
13062 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
13064 expression = TREE_OPERAND (expression, 1);
13065 if (TREE_CODE (expression) == IDENTIFIER_NODE)
13068 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
13069 if (TREE_CODE (expression) == SCOPE_REF)
13072 if (TREE_CODE (expression) == BASELINK)
13073 expression = BASELINK_FUNCTIONS (expression);
13075 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
13077 if (any_dependent_template_arguments_p
13078 (TREE_OPERAND (expression, 1)))
13080 expression = TREE_OPERAND (expression, 0);
13082 gcc_assert (TREE_CODE (expression) == OVERLOAD
13083 || TREE_CODE (expression) == FUNCTION_DECL);
13087 if (type_dependent_expression_p (OVL_CURRENT (expression)))
13089 expression = OVL_NEXT (expression);
13094 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
13096 return (dependent_type_p (TREE_TYPE (expression)));
13099 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
13100 contains a type-dependent expression. */
13103 any_type_dependent_arguments_p (tree args)
13107 tree arg = TREE_VALUE (args);
13109 if (type_dependent_expression_p (arg))
13111 args = TREE_CHAIN (args);
13116 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
13117 expressions) contains any value-dependent expressions. */
13120 any_value_dependent_elements_p (tree list)
13122 for (; list; list = TREE_CHAIN (list))
13123 if (value_dependent_expression_p (TREE_VALUE (list)))
13129 /* Returns TRUE if the ARG (a template argument) is dependent. */
13132 dependent_template_arg_p (tree arg)
13134 if (!processing_template_decl)
13137 if (TREE_CODE (arg) == TEMPLATE_DECL
13138 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
13139 return dependent_template_p (arg);
13140 else if (TYPE_P (arg))
13141 return dependent_type_p (arg);
13143 return (type_dependent_expression_p (arg)
13144 || value_dependent_expression_p (arg));
13147 /* Returns true if ARGS (a collection of template arguments) contains
13148 any dependent arguments. */
13151 any_dependent_template_arguments_p (tree args)
13158 if (args == error_mark_node)
13161 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
13163 tree level = TMPL_ARGS_LEVEL (args, i + 1);
13164 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
13165 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
13172 /* Returns TRUE if the template TMPL is dependent. */
13175 dependent_template_p (tree tmpl)
13177 if (TREE_CODE (tmpl) == OVERLOAD)
13181 if (dependent_template_p (OVL_FUNCTION (tmpl)))
13183 tmpl = OVL_CHAIN (tmpl);
13188 /* Template template parameters are dependent. */
13189 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
13190 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
13192 /* So are names that have not been looked up. */
13193 if (TREE_CODE (tmpl) == SCOPE_REF
13194 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
13196 /* So are member templates of dependent classes. */
13197 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
13198 return dependent_type_p (DECL_CONTEXT (tmpl));
13202 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
13205 dependent_template_id_p (tree tmpl, tree args)
13207 return (dependent_template_p (tmpl)
13208 || any_dependent_template_arguments_p (args));
13211 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
13212 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
13213 can be found. Note that this function peers inside uninstantiated
13214 templates and therefore should be used only in extremely limited
13215 situations. ONLY_CURRENT_P restricts this peering to the currently
13216 open classes hierarchy (which is required when comparing types). */
13219 resolve_typename_type (tree type, bool only_current_p)
13227 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
13229 scope = TYPE_CONTEXT (type);
13230 name = TYPE_IDENTIFIER (type);
13232 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
13233 it first before we can figure out what NAME refers to. */
13234 if (TREE_CODE (scope) == TYPENAME_TYPE)
13235 scope = resolve_typename_type (scope, only_current_p);
13236 /* If we don't know what SCOPE refers to, then we cannot resolve the
13238 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
13239 return error_mark_node;
13240 /* If the SCOPE is a template type parameter, we have no way of
13241 resolving the name. */
13242 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
13244 /* If the SCOPE is not the current instantiation, there's no reason
13245 to look inside it. */
13246 if (only_current_p && !currently_open_class (scope))
13247 return error_mark_node;
13248 /* If SCOPE is a partial instantiation, it will not have a valid
13249 TYPE_FIELDS list, so use the original template. */
13250 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
13251 /* Enter the SCOPE so that name lookup will be resolved as if we
13252 were in the class definition. In particular, SCOPE will no
13253 longer be considered a dependent type. */
13254 pushed_scope = push_scope (scope);
13255 /* Look up the declaration. */
13256 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
13257 /* Obtain the set of qualifiers applied to the TYPE. */
13258 quals = cp_type_quals (type);
13259 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
13260 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
13262 type = error_mark_node;
13263 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
13264 && TREE_CODE (decl) == TYPE_DECL)
13265 type = TREE_TYPE (decl);
13266 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
13267 && DECL_CLASS_TEMPLATE_P (decl))
13271 /* Obtain the template and the arguments. */
13272 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
13273 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
13274 /* Instantiate the template. */
13275 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
13276 /*entering_scope=*/0, tf_error | tf_user);
13279 type = error_mark_node;
13280 /* Qualify the resulting type. */
13281 if (type != error_mark_node && quals)
13282 type = cp_build_qualified_type (type, quals);
13283 /* Leave the SCOPE. */
13285 pop_scope (pushed_scope);
13290 /* EXPR is an expression which is not type-dependent. Return a proxy
13291 for EXPR that can be used to compute the types of larger
13292 expressions containing EXPR. */
13295 build_non_dependent_expr (tree expr)
13299 /* Preserve null pointer constants so that the type of things like
13300 "p == 0" where "p" is a pointer can be determined. */
13301 if (null_ptr_cst_p (expr))
13303 /* Preserve OVERLOADs; the functions must be available to resolve
13306 if (TREE_CODE (inner_expr) == ADDR_EXPR)
13307 inner_expr = TREE_OPERAND (inner_expr, 0);
13308 if (TREE_CODE (inner_expr) == COMPONENT_REF)
13309 inner_expr = TREE_OPERAND (inner_expr, 1);
13310 if (is_overloaded_fn (inner_expr)
13311 || TREE_CODE (inner_expr) == OFFSET_REF)
13313 /* There is no need to return a proxy for a variable. */
13314 if (TREE_CODE (expr) == VAR_DECL)
13316 /* Preserve string constants; conversions from string constants to
13317 "char *" are allowed, even though normally a "const char *"
13318 cannot be used to initialize a "char *". */
13319 if (TREE_CODE (expr) == STRING_CST)
13321 /* Preserve arithmetic constants, as an optimization -- there is no
13322 reason to create a new node. */
13323 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
13325 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
13326 There is at least one place where we want to know that a
13327 particular expression is a throw-expression: when checking a ?:
13328 expression, there are special rules if the second or third
13329 argument is a throw-expression. */
13330 if (TREE_CODE (expr) == THROW_EXPR)
13333 if (TREE_CODE (expr) == COND_EXPR)
13334 return build3 (COND_EXPR,
13336 TREE_OPERAND (expr, 0),
13337 (TREE_OPERAND (expr, 1)
13338 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
13339 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
13340 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
13341 if (TREE_CODE (expr) == COMPOUND_EXPR
13342 && !COMPOUND_EXPR_OVERLOADED (expr))
13343 return build2 (COMPOUND_EXPR,
13345 TREE_OPERAND (expr, 0),
13346 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
13348 /* If the type is unknown, it can't really be non-dependent */
13349 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
13351 /* Otherwise, build a NON_DEPENDENT_EXPR.
13353 REFERENCE_TYPEs are not stripped for expressions in templates
13354 because doing so would play havoc with mangling. Consider, for
13357 template <typename T> void f<T& g>() { g(); }
13359 In the body of "f", the expression for "g" will have
13360 REFERENCE_TYPE, even though the standard says that it should
13361 not. The reason is that we must preserve the syntactic form of
13362 the expression so that mangling (say) "f<g>" inside the body of
13363 "f" works out correctly. Therefore, the REFERENCE_TYPE is
13365 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
13368 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
13369 Return a new TREE_LIST with the various arguments replaced with
13370 equivalent non-dependent expressions. */
13373 build_non_dependent_args (tree args)
13378 new_args = NULL_TREE;
13379 for (a = args; a; a = TREE_CHAIN (a))
13380 new_args = tree_cons (NULL_TREE,
13381 build_non_dependent_expr (TREE_VALUE (a)),
13383 return nreverse (new_args);
13386 #include "gt-cp-pt.h"