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"
49 /* The type of functions taking a tree, and some additional data, and
51 typedef int (*tree_fn_t) (tree, void*);
53 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
54 instantiations have been deferred, either because their definitions
55 were not yet available, or because we were putting off doing the work.
56 The TREE_PURPOSE of each entry is either a DECL (for a function or
57 static data member), or a TYPE (for a class) indicating what we are
58 hoping to instantiate. The TREE_VALUE is not used. */
59 static GTY(()) tree pending_templates;
60 static GTY(()) tree last_pending_template;
62 int processing_template_parmlist;
63 static int template_header_count;
65 static GTY(()) tree saved_trees;
66 static GTY(()) varray_type inline_parm_levels;
67 static size_t inline_parm_levels_used;
69 static GTY(()) tree current_tinst_level;
71 static GTY(()) tree saved_access_scope;
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76 static tree cur_stmt_expr;
78 /* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
81 static htab_t local_specializations;
83 #define UNIFY_ALLOW_NONE 0
84 #define UNIFY_ALLOW_MORE_CV_QUAL 1
85 #define UNIFY_ALLOW_LESS_CV_QUAL 2
86 #define UNIFY_ALLOW_DERIVED 4
87 #define UNIFY_ALLOW_INTEGER 8
88 #define UNIFY_ALLOW_OUTER_LEVEL 16
89 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
90 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
92 static void push_access_scope (tree);
93 static void pop_access_scope (tree);
94 static int resolve_overloaded_unification (tree, tree, tree, tree,
95 unification_kind_t, int);
96 static int try_one_overload (tree, tree, tree, tree, tree,
97 unification_kind_t, int, bool);
98 static int unify (tree, tree, tree, tree, int);
99 static void add_pending_template (tree);
100 static void reopen_tinst_level (tree);
101 static tree classtype_mangled_name (tree);
102 static char* mangle_class_name_for_template (const char *, tree, tree);
103 static tree tsubst_initializer_list (tree, tree);
104 static tree get_class_bindings (tree, tree, tree);
105 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t, int);
106 static void tsubst_enum (tree, tree, tree);
107 static tree add_to_template_args (tree, tree);
108 static tree add_outermost_template_args (tree, tree);
109 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
110 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
111 static int type_unification_real (tree, tree, tree, tree,
112 int, unification_kind_t, int);
113 static void note_template_header (int);
114 static tree convert_nontype_argument_function (tree, tree);
115 static tree convert_nontype_argument (tree, tree);
116 static tree convert_template_argument (tree, tree, tree,
117 tsubst_flags_t, int, tree);
118 static int for_each_template_parm (tree, tree_fn_t, void*,
119 struct pointer_set_t*);
120 static tree build_template_parm_index (int, int, int, tree, tree);
121 static int inline_needs_template_parms (tree);
122 static void push_inline_template_parms_recursive (tree, int);
123 static tree retrieve_local_specialization (tree);
124 static void register_local_specialization (tree, tree);
125 static tree reduce_template_parm_level (tree, tree, int);
126 static int mark_template_parm (tree, void *);
127 static int template_parm_this_level_p (tree, void *);
128 static tree tsubst_friend_function (tree, tree);
129 static tree tsubst_friend_class (tree, tree);
130 static int can_complete_type_without_circularity (tree);
131 static tree get_bindings (tree, tree, tree, bool);
132 static int template_decl_level (tree);
133 static int check_cv_quals_for_unify (int, tree, tree);
134 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
135 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
136 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
137 static void regenerate_decl_from_template (tree, tree);
138 static tree most_specialized (tree, tree, tree);
139 static tree most_specialized_class (tree, tree);
140 static int template_class_depth_real (tree, int);
141 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
142 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
143 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
144 static void check_specialization_scope (void);
145 static tree process_partial_specialization (tree);
146 static void set_current_access_from_decl (tree);
147 static void check_default_tmpl_args (tree, tree, int, int);
148 static tree tsubst_call_declarator_parms (tree, tree, tsubst_flags_t, tree);
149 static tree get_template_base (tree, tree, tree, tree);
150 static int verify_class_unification (tree, tree, tree);
151 static tree try_class_unification (tree, tree, tree, tree);
152 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
154 static tree determine_specialization (tree, tree, tree *, int, int);
155 static int template_args_equal (tree, tree);
156 static void tsubst_default_arguments (tree);
157 static tree for_each_template_parm_r (tree *, int *, void *);
158 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
159 static void copy_default_args_to_explicit_spec (tree);
160 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
161 static int eq_local_specializations (const void *, const void *);
162 static bool dependent_type_p_r (tree);
163 static tree tsubst (tree, tree, tsubst_flags_t, tree);
164 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree);
165 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
167 /* Make the current scope suitable for access checking when we are
168 processing T. T can be FUNCTION_DECL for instantiated function
169 template, or VAR_DECL for static member variable (need by
170 instantiate_decl). */
173 push_access_scope (tree t)
175 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
176 || TREE_CODE (t) == VAR_DECL);
178 if (DECL_FRIEND_CONTEXT (t))
179 push_nested_class (DECL_FRIEND_CONTEXT (t));
180 else if (DECL_CLASS_SCOPE_P (t))
181 push_nested_class (DECL_CONTEXT (t));
183 push_to_top_level ();
185 if (TREE_CODE (t) == FUNCTION_DECL)
187 saved_access_scope = tree_cons
188 (NULL_TREE, current_function_decl, saved_access_scope);
189 current_function_decl = t;
193 /* Restore the scope set up by push_access_scope. T is the node we
197 pop_access_scope (tree t)
199 if (TREE_CODE (t) == FUNCTION_DECL)
201 current_function_decl = TREE_VALUE (saved_access_scope);
202 saved_access_scope = TREE_CHAIN (saved_access_scope);
205 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
208 pop_from_top_level ();
211 /* Do any processing required when DECL (a member template
212 declaration) is finished. Returns the TEMPLATE_DECL corresponding
213 to DECL, unless it is a specialization, in which case the DECL
214 itself is returned. */
217 finish_member_template_decl (tree decl)
219 if (decl == error_mark_node)
220 return error_mark_node;
222 gcc_assert (DECL_P (decl));
224 if (TREE_CODE (decl) == TYPE_DECL)
228 type = TREE_TYPE (decl);
229 if (IS_AGGR_TYPE (type)
230 && CLASSTYPE_TEMPLATE_INFO (type)
231 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
233 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
234 check_member_template (tmpl);
239 else if (TREE_CODE (decl) == FIELD_DECL)
240 error ("data member %qD cannot be a member template", decl);
241 else if (DECL_TEMPLATE_INFO (decl))
243 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
245 check_member_template (DECL_TI_TEMPLATE (decl));
246 return DECL_TI_TEMPLATE (decl);
252 error ("invalid member template declaration %qD", decl);
254 return error_mark_node;
257 /* Returns the template nesting level of the indicated class TYPE.
267 A<T>::B<U> has depth two, while A<T> has depth one.
268 Both A<T>::B<int> and A<int>::B<U> have depth one, if
269 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
272 This function is guaranteed to return 0 if passed NULL_TREE so
273 that, for example, `template_class_depth (current_class_type)' is
277 template_class_depth_real (tree type, int count_specializations)
282 type && TREE_CODE (type) != NAMESPACE_DECL;
283 type = (TREE_CODE (type) == FUNCTION_DECL)
284 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
286 if (TREE_CODE (type) != FUNCTION_DECL)
288 if (CLASSTYPE_TEMPLATE_INFO (type)
289 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
290 && ((count_specializations
291 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
292 || uses_template_parms (CLASSTYPE_TI_ARGS (type))))
297 if (DECL_TEMPLATE_INFO (type)
298 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
299 && ((count_specializations
300 && DECL_TEMPLATE_SPECIALIZATION (type))
301 || uses_template_parms (DECL_TI_ARGS (type))))
309 /* Returns the template nesting level of the indicated class TYPE.
310 Like template_class_depth_real, but instantiations do not count in
314 template_class_depth (tree type)
316 return template_class_depth_real (type, /*count_specializations=*/0);
319 /* Returns 1 if processing DECL as part of do_pending_inlines
320 needs us to push template parms. */
323 inline_needs_template_parms (tree decl)
325 if (! DECL_TEMPLATE_INFO (decl))
328 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
329 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
332 /* Subroutine of maybe_begin_member_template_processing.
333 Push the template parms in PARMS, starting from LEVELS steps into the
334 chain, and ending at the beginning, since template parms are listed
338 push_inline_template_parms_recursive (tree parmlist, int levels)
340 tree parms = TREE_VALUE (parmlist);
344 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
346 ++processing_template_decl;
347 current_template_parms
348 = tree_cons (size_int (processing_template_decl),
349 parms, current_template_parms);
350 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
352 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
354 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
356 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
357 gcc_assert (DECL_P (parm));
359 switch (TREE_CODE (parm))
368 /* Make a CONST_DECL as is done in process_template_parm.
369 It is ugly that we recreate this here; the original
370 version built in process_template_parm is no longer
372 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
374 DECL_ARTIFICIAL (decl) = 1;
375 TREE_CONSTANT (decl) = 1;
376 TREE_INVARIANT (decl) = 1;
377 TREE_READONLY (decl) = 1;
378 DECL_INITIAL (decl) = DECL_INITIAL (parm);
379 SET_DECL_TEMPLATE_PARM_P (decl);
390 /* Restore the template parameter context for a member template or
391 a friend template defined in a class definition. */
394 maybe_begin_member_template_processing (tree decl)
399 if (inline_needs_template_parms (decl))
401 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
402 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
404 if (DECL_TEMPLATE_SPECIALIZATION (decl))
407 parms = TREE_CHAIN (parms);
410 push_inline_template_parms_recursive (parms, levels);
413 /* Remember how many levels of template parameters we pushed so that
414 we can pop them later. */
415 if (!inline_parm_levels)
416 VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels");
417 if (inline_parm_levels_used == inline_parm_levels->num_elements)
418 VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used);
419 VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels;
420 ++inline_parm_levels_used;
423 /* Undo the effects of maybe_begin_member_template_processing. */
426 maybe_end_member_template_processing (void)
430 if (!inline_parm_levels_used)
433 --inline_parm_levels_used;
435 i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used);
438 --processing_template_decl;
439 current_template_parms = TREE_CHAIN (current_template_parms);
444 /* Return a new template argument vector which contains all of ARGS,
445 but has as its innermost set of arguments the EXTRA_ARGS. */
448 add_to_template_args (tree args, tree extra_args)
455 extra_depth = TMPL_ARGS_DEPTH (extra_args);
456 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
458 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
459 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
461 for (j = 1; j <= extra_depth; ++j, ++i)
462 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
467 /* Like add_to_template_args, but only the outermost ARGS are added to
468 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
469 (EXTRA_ARGS) levels are added. This function is used to combine
470 the template arguments from a partial instantiation with the
471 template arguments used to attain the full instantiation from the
472 partial instantiation. */
475 add_outermost_template_args (tree args, tree extra_args)
479 /* If there are more levels of EXTRA_ARGS than there are ARGS,
480 something very fishy is going on. */
481 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
483 /* If *all* the new arguments will be the EXTRA_ARGS, just return
485 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
488 /* For the moment, we make ARGS look like it contains fewer levels. */
489 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
491 new_args = add_to_template_args (args, extra_args);
493 /* Now, we restore ARGS to its full dimensions. */
494 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
499 /* Return the N levels of innermost template arguments from the ARGS. */
502 get_innermost_template_args (tree args, int n)
510 /* If N is 1, just return the innermost set of template arguments. */
512 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
514 /* If we're not removing anything, just return the arguments we were
516 extra_levels = TMPL_ARGS_DEPTH (args) - n;
517 gcc_assert (extra_levels >= 0);
518 if (extra_levels == 0)
521 /* Make a new set of arguments, not containing the outer arguments. */
522 new_args = make_tree_vec (n);
523 for (i = 1; i <= n; ++i)
524 SET_TMPL_ARGS_LEVEL (new_args, i,
525 TMPL_ARGS_LEVEL (args, i + extra_levels));
530 /* We've got a template header coming up; push to a new level for storing
534 begin_template_parm_list (void)
536 /* We use a non-tag-transparent scope here, which causes pushtag to
537 put tags in this scope, rather than in the enclosing class or
538 namespace scope. This is the right thing, since we want
539 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
540 global template class, push_template_decl handles putting the
541 TEMPLATE_DECL into top-level scope. For a nested template class,
544 template <class T> struct S1 {
545 template <class T> struct S2 {};
548 pushtag contains special code to call pushdecl_with_scope on the
549 TEMPLATE_DECL for S2. */
550 begin_scope (sk_template_parms, NULL);
551 ++processing_template_decl;
552 ++processing_template_parmlist;
553 note_template_header (0);
556 /* This routine is called when a specialization is declared. If it is
557 invalid to declare a specialization here, an error is reported. */
560 check_specialization_scope (void)
562 tree scope = current_scope ();
566 An explicit specialization shall be declared in the namespace of
567 which the template is a member, or, for member templates, in the
568 namespace of which the enclosing class or enclosing class
569 template is a member. An explicit specialization of a member
570 function, member class or static data member of a class template
571 shall be declared in the namespace of which the class template
573 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
574 error ("explicit specialization in non-namespace scope %qD", scope);
578 In an explicit specialization declaration for a member of a class
579 template or a member template that appears in namespace scope,
580 the member template and some of its enclosing class templates may
581 remain unspecialized, except that the declaration shall not
582 explicitly specialize a class member template if its enclosing
583 class templates are not explicitly specialized as well. */
584 if (current_template_parms)
585 error ("enclosing class templates are not explicitly specialized");
588 /* We've just seen template <>. */
591 begin_specialization (void)
593 begin_scope (sk_template_spec, NULL);
594 note_template_header (1);
595 check_specialization_scope ();
598 /* Called at then end of processing a declaration preceded by
602 end_specialization (void)
605 reset_specialization ();
608 /* Any template <>'s that we have seen thus far are not referring to a
609 function specialization. */
612 reset_specialization (void)
614 processing_specialization = 0;
615 template_header_count = 0;
618 /* We've just seen a template header. If SPECIALIZATION is nonzero,
619 it was of the form template <>. */
622 note_template_header (int specialization)
624 processing_specialization = specialization;
625 template_header_count++;
628 /* We're beginning an explicit instantiation. */
631 begin_explicit_instantiation (void)
633 gcc_assert (!processing_explicit_instantiation);
634 processing_explicit_instantiation = true;
639 end_explicit_instantiation (void)
641 gcc_assert (processing_explicit_instantiation);
642 processing_explicit_instantiation = false;
645 /* An explicit specialization or partial specialization TMPL is being
646 declared. Check that the namespace in which the specialization is
647 occurring is permissible. Returns false iff it is invalid to
648 specialize TMPL in the current namespace. */
651 check_specialization_namespace (tree tmpl)
653 tree tpl_ns = decl_namespace_context (tmpl);
657 An explicit specialization shall be declared in the namespace of
658 which the template is a member, or, for member templates, in the
659 namespace of which the enclosing class or enclosing class
660 template is a member. An explicit specialization of a member
661 function, member class or static data member of a class template
662 shall be declared in the namespace of which the class template is
664 if (is_associated_namespace (current_namespace, tpl_ns))
665 /* Same or super-using namespace. */
669 pedwarn ("specialization of %qD in different namespace", tmpl);
670 pedwarn (" from definition of %q+#D", tmpl);
675 /* The TYPE is being declared. If it is a template type, that means it
676 is a partial specialization. Do appropriate error-checking. */
679 maybe_process_partial_specialization (tree type)
681 /* TYPE maybe an ERROR_MARK_NODE. */
682 tree context = TYPE_P (type) ? TYPE_CONTEXT (type) : NULL_TREE;
684 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
686 /* This is for ordinary explicit specialization and partial
687 specialization of a template class such as:
689 template <> class C<int>;
693 template <class T> class C<T*>;
695 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
697 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
698 && !COMPLETE_TYPE_P (type))
700 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
701 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
702 if (processing_template_decl)
703 push_template_decl (TYPE_MAIN_DECL (type));
705 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
706 error ("specialization of %qT after instantiation", type);
708 else if (CLASS_TYPE_P (type)
709 && !CLASSTYPE_USE_TEMPLATE (type)
710 && CLASSTYPE_TEMPLATE_INFO (type)
711 && context && CLASS_TYPE_P (context)
712 && CLASSTYPE_TEMPLATE_INFO (context))
714 /* This is for an explicit specialization of member class
715 template according to [temp.expl.spec/18]:
717 template <> template <class U> class C<int>::D;
719 The context `C<int>' must be an implicit instantiation.
720 Otherwise this is just a member class template declared
723 template <> class C<int> { template <class U> class D; };
724 template <> template <class U> class C<int>::D;
726 In the first case, `C<int>::D' is a specialization of `C<T>::D'
727 while in the second case, `C<int>::D' is a primary template
728 and `C<T>::D' may not exist. */
730 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
731 && !COMPLETE_TYPE_P (type))
735 if (current_namespace
736 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
738 pedwarn ("specializing %q#T in different namespace", type);
739 pedwarn (" from definition of %q+#D",
740 CLASSTYPE_TI_TEMPLATE (type));
743 /* Check for invalid specialization after instantiation:
745 template <> template <> class C<int>::D<int>;
746 template <> template <class U> class C<int>::D; */
748 for (t = DECL_TEMPLATE_INSTANTIATIONS
749 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
750 t; t = TREE_CHAIN (t))
751 if (TREE_VALUE (t) != type
752 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
753 error ("specialization %qT after instantiation %qT",
754 type, TREE_VALUE (t));
756 /* Mark TYPE as a specialization. And as a result, we only
757 have one level of template argument for the innermost
759 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
760 CLASSTYPE_TI_ARGS (type)
761 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
764 else if (processing_specialization)
765 error ("explicit specialization of non-template %qT", type);
768 /* Returns nonzero if we can optimize the retrieval of specializations
769 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
770 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
773 optimize_specialization_lookup_p (tree tmpl)
775 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
776 && DECL_CLASS_SCOPE_P (tmpl)
777 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
779 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
780 /* The optimized lookup depends on the fact that the
781 template arguments for the member function template apply
782 purely to the containing class, which is not true if the
783 containing class is an explicit or partial
785 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
786 && !DECL_MEMBER_TEMPLATE_P (tmpl)
787 && !DECL_CONV_FN_P (tmpl)
788 /* It is possible to have a template that is not a member
789 template and is not a member of a template class:
791 template <typename T>
792 struct S { friend A::f(); };
794 Here, the friend function is a template, but the context does
795 not have template information. The optimized lookup relies
796 on having ARGS be the template arguments for both the class
797 and the function template. */
798 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
801 /* Retrieve the specialization (in the sense of [temp.spec] - a
802 specialization is either an instantiation or an explicit
803 specialization) of TMPL for the given template ARGS. If there is
804 no such specialization, return NULL_TREE. The ARGS are a vector of
805 arguments, or a vector of vectors of arguments, in the case of
806 templates with more than one level of parameters.
808 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
809 then we search for a partial specialization matching ARGS. This
810 parameter is ignored if TMPL is not a class template. */
813 retrieve_specialization (tree tmpl, tree args,
814 bool class_specializations_p)
816 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
818 /* There should be as many levels of arguments as there are
819 levels of parameters. */
820 gcc_assert (TMPL_ARGS_DEPTH (args)
821 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
823 if (optimize_specialization_lookup_p (tmpl))
826 tree class_specialization;
827 VEC(tree,gc) *methods;
831 /* The template arguments actually apply to the containing
832 class. Find the class specialization with those
834 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
836 = retrieve_specialization (class_template, args,
837 /*class_specializations_p=*/false);
838 if (!class_specialization)
840 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
841 for the specialization. */
842 idx = class_method_index_for_fn (class_specialization, tmpl);
845 /* Iterate through the methods with the indicated name, looking
846 for the one that has an instance of TMPL. */
847 methods = CLASSTYPE_METHOD_VEC (class_specialization);
848 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
850 tree fn = OVL_CURRENT (fns);
851 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
861 /* Class templates store their instantiations on the
862 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
863 DECL_TEMPLATE_SPECIALIZATIONS list. */
864 if (!class_specializations_p
865 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
866 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
868 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
870 /* Iterate through the list until we find a matching template. */
871 while (*sp != NULL_TREE)
875 if (comp_template_args (TREE_PURPOSE (spec), args))
877 /* Use the move-to-front heuristic to speed up future
881 *sp = TREE_CHAIN (*sp);
882 TREE_CHAIN (spec) = *head;
885 return TREE_VALUE (spec);
887 sp = &TREE_CHAIN (spec);
894 /* Like retrieve_specialization, but for local declarations. */
897 retrieve_local_specialization (tree tmpl)
899 tree spec = htab_find_with_hash (local_specializations, tmpl,
900 htab_hash_pointer (tmpl));
901 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
904 /* Returns nonzero iff DECL is a specialization of TMPL. */
907 is_specialization_of (tree decl, tree tmpl)
911 if (TREE_CODE (decl) == FUNCTION_DECL)
915 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
921 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
923 for (t = TREE_TYPE (decl);
925 t = CLASSTYPE_USE_TEMPLATE (t)
926 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
927 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
934 /* Returns nonzero iff DECL is a specialization of friend declaration
935 FRIEND according to [temp.friend]. */
938 is_specialization_of_friend (tree decl, tree friend)
940 bool need_template = true;
943 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
944 || TREE_CODE (decl) == TYPE_DECL);
946 /* For [temp.friend/6] when FRIEND is an ordinary member function
947 of a template class, we want to check if DECL is a specialization
949 if (TREE_CODE (friend) == FUNCTION_DECL
950 && DECL_TEMPLATE_INFO (friend)
951 && !DECL_USE_TEMPLATE (friend))
953 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
954 friend = DECL_TI_TEMPLATE (friend);
955 need_template = false;
957 else if (TREE_CODE (friend) == TEMPLATE_DECL
958 && !PRIMARY_TEMPLATE_P (friend))
959 need_template = false;
961 /* There is nothing to do if this is not a template friend. */
962 if (TREE_CODE (friend) != TEMPLATE_DECL)
965 if (is_specialization_of (decl, friend))
969 A member of a class template may be declared to be a friend of a
970 non-template class. In this case, the corresponding member of
971 every specialization of the class template is a friend of the
972 class granting friendship.
974 For example, given a template friend declaration
976 template <class T> friend void A<T>::f();
978 the member function below is considered a friend
980 template <> struct A<int> {
984 For this type of template friend, TEMPLATE_DEPTH below will be
985 nonzero. To determine if DECL is a friend of FRIEND, we first
986 check if the enclosing class is a specialization of another. */
988 template_depth = template_class_depth (DECL_CONTEXT (friend));
990 && DECL_CLASS_SCOPE_P (decl)
991 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
992 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
994 /* Next, we check the members themselves. In order to handle
995 a few tricky cases, such as when FRIEND's are
997 template <class T> friend void A<T>::g(T t);
998 template <class T> template <T t> friend void A<T>::h();
1002 void A<int>::g(int);
1003 template <int> void A<int>::h();
1005 we need to figure out ARGS, the template arguments from
1006 the context of DECL. This is required for template substitution
1007 of `T' in the function parameter of `g' and template parameter
1008 of `h' in the above examples. Here ARGS corresponds to `int'. */
1010 tree context = DECL_CONTEXT (decl);
1011 tree args = NULL_TREE;
1012 int current_depth = 0;
1014 while (current_depth < template_depth)
1016 if (CLASSTYPE_TEMPLATE_INFO (context))
1018 if (current_depth == 0)
1019 args = TYPE_TI_ARGS (context);
1021 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1024 context = TYPE_CONTEXT (context);
1027 if (TREE_CODE (decl) == FUNCTION_DECL)
1032 tree friend_args_type;
1033 tree decl_args_type;
1035 /* Make sure that both DECL and FRIEND are templates or
1037 is_template = DECL_TEMPLATE_INFO (decl)
1038 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1039 if (need_template ^ is_template)
1041 else if (is_template)
1043 /* If both are templates, check template parameter list. */
1045 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1047 if (!comp_template_parms
1048 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1052 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1055 decl_type = TREE_TYPE (decl);
1057 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1058 tf_none, NULL_TREE);
1059 if (friend_type == error_mark_node)
1062 /* Check if return types match. */
1063 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1066 /* Check if function parameter types match, ignoring the
1067 `this' parameter. */
1068 friend_args_type = TYPE_ARG_TYPES (friend_type);
1069 decl_args_type = TYPE_ARG_TYPES (decl_type);
1070 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1071 friend_args_type = TREE_CHAIN (friend_args_type);
1072 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1073 decl_args_type = TREE_CHAIN (decl_args_type);
1075 return compparms (decl_args_type, friend_args_type);
1079 /* DECL is a TYPE_DECL */
1081 tree decl_type = TREE_TYPE (decl);
1083 /* Make sure that both DECL and FRIEND are templates or
1086 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1087 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1089 if (need_template ^ is_template)
1091 else if (is_template)
1094 /* If both are templates, check the name of the two
1095 TEMPLATE_DECL's first because is_friend didn't. */
1096 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1097 != DECL_NAME (friend))
1100 /* Now check template parameter list. */
1102 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1104 return comp_template_parms
1105 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1109 return (DECL_NAME (decl)
1110 == DECL_NAME (friend));
1116 /* Register the specialization SPEC as a specialization of TMPL with
1117 the indicated ARGS. IS_FRIEND indicates whether the specialization
1118 is actually just a friend declaration. Returns SPEC, or an
1119 equivalent prior declaration, if available. */
1122 register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1126 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1128 if (TREE_CODE (spec) == FUNCTION_DECL
1129 && uses_template_parms (DECL_TI_ARGS (spec)))
1130 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1131 register it; we want the corresponding TEMPLATE_DECL instead.
1132 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1133 the more obvious `uses_template_parms (spec)' to avoid problems
1134 with default function arguments. In particular, given
1135 something like this:
1137 template <class T> void f(T t1, T t = T())
1139 the default argument expression is not substituted for in an
1140 instantiation unless and until it is actually needed. */
1143 fn = retrieve_specialization (tmpl, args,
1144 /*class_specializations_p=*/false);
1145 /* We can sometimes try to re-register a specialization that we've
1146 already got. In particular, regenerate_decl_from_template calls
1147 duplicate_decls which will update the specialization list. But,
1148 we'll still get called again here anyhow. It's more convenient
1149 to simply allow this than to try to prevent it. */
1152 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1154 if (DECL_TEMPLATE_INSTANTIATION (fn))
1157 || DECL_EXPLICIT_INSTANTIATION (fn))
1159 error ("specialization of %qD after instantiation",
1165 /* This situation should occur only if the first
1166 specialization is an implicit instantiation, the
1167 second is an explicit specialization, and the
1168 implicit instantiation has not yet been used. That
1169 situation can occur if we have implicitly
1170 instantiated a member function and then specialized
1173 We can also wind up here if a friend declaration that
1174 looked like an instantiation turns out to be a
1177 template <class T> void foo(T);
1178 class S { friend void foo<>(int) };
1179 template <> void foo(int);
1181 We transform the existing DECL in place so that any
1182 pointers to it become pointers to the updated
1185 If there was a definition for the template, but not
1186 for the specialization, we want this to look as if
1187 there were no definition, and vice versa. */
1188 DECL_INITIAL (fn) = NULL_TREE;
1189 duplicate_decls (spec, fn, is_friend);
1194 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1196 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1197 /* Dup decl failed, but this is a new definition. Set the
1198 line number so any errors match this new
1200 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1206 /* A specialization must be declared in the same namespace as the
1207 template it is specializing. */
1208 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1209 && !check_specialization_namespace (tmpl))
1210 DECL_CONTEXT (spec) = decl_namespace_context (tmpl);
1212 if (!optimize_specialization_lookup_p (tmpl))
1213 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1214 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1219 /* Unregister the specialization SPEC as a specialization of TMPL.
1220 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1221 if the SPEC was listed as a specialization of TMPL. */
1224 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1228 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1230 s = &TREE_CHAIN (*s))
1231 if (TREE_VALUE (*s) == spec)
1234 *s = TREE_CHAIN (*s);
1236 TREE_VALUE (*s) = new_spec;
1243 /* Compare an entry in the local specializations hash table P1 (which
1244 is really a pointer to a TREE_LIST) with P2 (which is really a
1248 eq_local_specializations (const void *p1, const void *p2)
1250 return TREE_VALUE ((tree) p1) == (tree) p2;
1253 /* Hash P1, an entry in the local specializations table. */
1256 hash_local_specialization (const void* p1)
1258 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1261 /* Like register_specialization, but for local declarations. We are
1262 registering SPEC, an instantiation of TMPL. */
1265 register_local_specialization (tree spec, tree tmpl)
1269 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1270 htab_hash_pointer (tmpl), INSERT);
1271 *slot = build_tree_list (spec, tmpl);
1274 /* Print the list of candidate FNS in an error message. */
1277 print_candidates (tree fns)
1281 const char *str = "candidates are:";
1283 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1287 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1288 error ("%s %+#D", str, OVL_CURRENT (f));
1293 /* Returns the template (one of the functions given by TEMPLATE_ID)
1294 which can be specialized to match the indicated DECL with the
1295 explicit template args given in TEMPLATE_ID. The DECL may be
1296 NULL_TREE if none is available. In that case, the functions in
1297 TEMPLATE_ID are non-members.
1299 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1300 specialization of a member template.
1302 The TEMPLATE_COUNT is the number of references to qualifying
1303 template classes that appeared in the name of the function. See
1304 check_explicit_specialization for a more accurate description.
1306 The template args (those explicitly specified and those deduced)
1307 are output in a newly created vector *TARGS_OUT.
1309 If it is impossible to determine the result, an error message is
1310 issued. The error_mark_node is returned to indicate failure. */
1313 determine_specialization (tree template_id,
1316 int need_member_template,
1321 tree explicit_targs;
1322 tree candidates = NULL_TREE;
1323 tree templates = NULL_TREE;
1325 struct cp_binding_level *b;
1327 *targs_out = NULL_TREE;
1329 if (template_id == error_mark_node)
1330 return error_mark_node;
1332 fns = TREE_OPERAND (template_id, 0);
1333 explicit_targs = TREE_OPERAND (template_id, 1);
1335 if (fns == error_mark_node)
1336 return error_mark_node;
1338 /* Check for baselinks. */
1339 if (BASELINK_P (fns))
1340 fns = BASELINK_FUNCTIONS (fns);
1342 if (!is_overloaded_fn (fns))
1344 error ("%qD is not a function template", fns);
1345 return error_mark_node;
1348 /* Count the number of template headers specified for this
1351 for (b = current_binding_level;
1352 b->kind == sk_template_parms;
1356 for (; fns; fns = OVL_NEXT (fns))
1358 tree fn = OVL_CURRENT (fns);
1360 if (TREE_CODE (fn) == TEMPLATE_DECL)
1362 tree decl_arg_types;
1365 /* DECL might be a specialization of FN. */
1367 /* Adjust the type of DECL in case FN is a static member. */
1368 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1369 if (DECL_STATIC_FUNCTION_P (fn)
1370 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1371 decl_arg_types = TREE_CHAIN (decl_arg_types);
1373 /* Check that the number of function parameters matches.
1375 template <class T> void f(int i = 0);
1376 template <> void f<int>();
1377 The specialization f<int> is invalid but is not caught
1378 by get_bindings below. */
1380 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1381 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1384 /* For a non-static member function, we need to make sure that
1385 the const qualification is the same. This can be done by
1386 checking the 'this' in the argument list. */
1387 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1388 && !same_type_p (TREE_VALUE (fn_arg_types),
1389 TREE_VALUE (decl_arg_types)))
1392 /* In case of explicit specialization, we need to check if
1393 the number of template headers appearing in the specialization
1394 is correct. This is usually done in check_explicit_specialization,
1395 but the check done there cannot be exhaustive when specializing
1396 member functions. Consider the following code:
1398 template <> void A<int>::f(int);
1399 template <> template <> void A<int>::f(int);
1401 Assuming that A<int> is not itself an explicit specialization
1402 already, the first line specializes "f" which is a non-template
1403 member function, whilst the second line specializes "f" which
1404 is a template member function. So both lines are syntactically
1405 correct, and check_explicit_specialization does not reject
1408 Here, we can do better, as we are matching the specialization
1409 against the declarations. We count the number of template
1410 headers, and we check if they match TEMPLATE_COUNT + 1
1411 (TEMPLATE_COUNT is the number of qualifying template classes,
1412 plus there must be another header for the member template
1415 Notice that if header_count is zero, this is not a
1416 specialization but rather a template instantiation, so there
1417 is no check we can perform here. */
1418 if (header_count && header_count != template_count + 1)
1421 /* Check that the number of template arguments at the
1422 innermost level for DECL is the same as for FN. */
1423 if (current_binding_level->kind == sk_template_parms
1424 && !current_binding_level->explicit_spec_p
1425 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1426 != TREE_VEC_LENGTH (TREE_VALUE (current_template_parms))))
1429 /* See whether this function might be a specialization of this
1431 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1434 /* We cannot deduce template arguments that when used to
1435 specialize TMPL will produce DECL. */
1438 /* Save this template, and the arguments deduced. */
1439 templates = tree_cons (targs, fn, templates);
1441 else if (need_member_template)
1442 /* FN is an ordinary member function, and we need a
1443 specialization of a member template. */
1445 else if (TREE_CODE (fn) != FUNCTION_DECL)
1446 /* We can get IDENTIFIER_NODEs here in certain erroneous
1449 else if (!DECL_FUNCTION_MEMBER_P (fn))
1450 /* This is just an ordinary non-member function. Nothing can
1451 be a specialization of that. */
1453 else if (DECL_ARTIFICIAL (fn))
1454 /* Cannot specialize functions that are created implicitly. */
1458 tree decl_arg_types;
1460 /* This is an ordinary member function. However, since
1461 we're here, we can assume it's enclosing class is a
1462 template class. For example,
1464 template <typename T> struct S { void f(); };
1465 template <> void S<int>::f() {}
1467 Here, S<int>::f is a non-template, but S<int> is a
1468 template class. If FN has the same type as DECL, we
1469 might be in business. */
1471 if (!DECL_TEMPLATE_INFO (fn))
1472 /* Its enclosing class is an explicit specialization
1473 of a template class. This is not a candidate. */
1476 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1477 TREE_TYPE (TREE_TYPE (fn))))
1478 /* The return types differ. */
1481 /* Adjust the type of DECL in case FN is a static member. */
1482 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1483 if (DECL_STATIC_FUNCTION_P (fn)
1484 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1485 decl_arg_types = TREE_CHAIN (decl_arg_types);
1487 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1490 candidates = tree_cons (NULL_TREE, fn, candidates);
1494 if (templates && TREE_CHAIN (templates))
1500 It is possible for a specialization with a given function
1501 signature to be instantiated from more than one function
1502 template. In such cases, explicit specification of the
1503 template arguments must be used to uniquely identify the
1504 function template specialization being specialized.
1506 Note that here, there's no suggestion that we're supposed to
1507 determine which of the candidate templates is most
1508 specialized. However, we, also have:
1512 Partial ordering of overloaded function template
1513 declarations is used in the following contexts to select
1514 the function template to which a function template
1515 specialization refers:
1517 -- when an explicit specialization refers to a function
1520 So, we do use the partial ordering rules, at least for now.
1521 This extension can only serve to make invalid programs valid,
1522 so it's safe. And, there is strong anecdotal evidence that
1523 the committee intended the partial ordering rules to apply;
1524 the EDG front-end has that behavior, and John Spicer claims
1525 that the committee simply forgot to delete the wording in
1526 [temp.expl.spec]. */
1527 tree tmpl = most_specialized (templates, decl, explicit_targs);
1528 if (tmpl && tmpl != error_mark_node)
1530 targs = get_bindings (tmpl, decl, explicit_targs, /*check_ret=*/true);
1531 templates = tree_cons (targs, tmpl, NULL_TREE);
1535 if (templates == NULL_TREE && candidates == NULL_TREE)
1537 error ("template-id %qD for %q+D does not match any template "
1538 "declaration", template_id, decl);
1539 return error_mark_node;
1541 else if ((templates && TREE_CHAIN (templates))
1542 || (candidates && TREE_CHAIN (candidates))
1543 || (templates && candidates))
1545 error ("ambiguous template specialization %qD for %q+D",
1547 chainon (candidates, templates);
1548 print_candidates (candidates);
1549 return error_mark_node;
1552 /* We have one, and exactly one, match. */
1555 /* It was a specialization of an ordinary member function in a
1557 *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates)));
1558 return DECL_TI_TEMPLATE (TREE_VALUE (candidates));
1561 /* It was a specialization of a template. */
1562 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1563 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1565 *targs_out = copy_node (targs);
1566 SET_TMPL_ARGS_LEVEL (*targs_out,
1567 TMPL_ARGS_DEPTH (*targs_out),
1568 TREE_PURPOSE (templates));
1571 *targs_out = TREE_PURPOSE (templates);
1572 return TREE_VALUE (templates);
1575 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1576 but with the default argument values filled in from those in the
1580 copy_default_args_to_explicit_spec_1 (tree spec_types,
1583 tree new_spec_types;
1588 if (spec_types == void_list_node)
1589 return void_list_node;
1591 /* Substitute into the rest of the list. */
1593 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1594 TREE_CHAIN (tmpl_types));
1596 /* Add the default argument for this parameter. */
1597 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1598 TREE_VALUE (spec_types),
1602 /* DECL is an explicit specialization. Replicate default arguments
1603 from the template it specializes. (That way, code like:
1605 template <class T> void f(T = 3);
1606 template <> void f(double);
1609 works, as required.) An alternative approach would be to look up
1610 the correct default arguments at the call-site, but this approach
1611 is consistent with how implicit instantiations are handled. */
1614 copy_default_args_to_explicit_spec (tree decl)
1619 tree new_spec_types;
1623 tree object_type = NULL_TREE;
1624 tree in_charge = NULL_TREE;
1625 tree vtt = NULL_TREE;
1627 /* See if there's anything we need to do. */
1628 tmpl = DECL_TI_TEMPLATE (decl);
1629 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1630 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1631 if (TREE_PURPOSE (t))
1636 old_type = TREE_TYPE (decl);
1637 spec_types = TYPE_ARG_TYPES (old_type);
1639 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1641 /* Remove the this pointer, but remember the object's type for
1643 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1644 spec_types = TREE_CHAIN (spec_types);
1645 tmpl_types = TREE_CHAIN (tmpl_types);
1647 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1649 /* DECL may contain more parameters than TMPL due to the extra
1650 in-charge parameter in constructors and destructors. */
1651 in_charge = spec_types;
1652 spec_types = TREE_CHAIN (spec_types);
1654 if (DECL_HAS_VTT_PARM_P (decl))
1657 spec_types = TREE_CHAIN (spec_types);
1661 /* Compute the merged default arguments. */
1663 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1665 /* Compute the new FUNCTION_TYPE. */
1669 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1674 /* Put the in-charge parameter back. */
1675 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1676 TREE_VALUE (in_charge),
1679 new_type = build_method_type_directly (object_type,
1680 TREE_TYPE (old_type),
1684 new_type = build_function_type (TREE_TYPE (old_type),
1686 new_type = cp_build_type_attribute_variant (new_type,
1687 TYPE_ATTRIBUTES (old_type));
1688 new_type = build_exception_variant (new_type,
1689 TYPE_RAISES_EXCEPTIONS (old_type));
1690 TREE_TYPE (decl) = new_type;
1693 /* Check to see if the function just declared, as indicated in
1694 DECLARATOR, and in DECL, is a specialization of a function
1695 template. We may also discover that the declaration is an explicit
1696 instantiation at this point.
1698 Returns DECL, or an equivalent declaration that should be used
1699 instead if all goes well. Issues an error message if something is
1700 amiss. Returns error_mark_node if the error is not easily
1703 FLAGS is a bitmask consisting of the following flags:
1705 2: The function has a definition.
1706 4: The function is a friend.
1708 The TEMPLATE_COUNT is the number of references to qualifying
1709 template classes that appeared in the name of the function. For
1712 template <class T> struct S { void f(); };
1715 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1716 classes are not counted in the TEMPLATE_COUNT, so that in
1718 template <class T> struct S {};
1719 template <> struct S<int> { void f(); }
1720 template <> void S<int>::f();
1722 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1723 invalid; there should be no template <>.)
1725 If the function is a specialization, it is marked as such via
1726 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1727 is set up correctly, and it is added to the list of specializations
1728 for that template. */
1731 check_explicit_specialization (tree declarator,
1736 int have_def = flags & 2;
1737 int is_friend = flags & 4;
1738 int specialization = 0;
1739 int explicit_instantiation = 0;
1740 int member_specialization = 0;
1741 tree ctype = DECL_CLASS_CONTEXT (decl);
1742 tree dname = DECL_NAME (decl);
1747 if (!processing_specialization)
1750 tsk = tsk_excessive_parms;
1753 tsk = current_tmpl_spec_kind (template_count);
1758 if (processing_specialization)
1761 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1763 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1766 /* This could be something like:
1768 template <class T> void f(T);
1769 class S { friend void f<>(int); } */
1773 /* This case handles bogus declarations like template <>
1774 template <class T> void f<int>(); */
1776 error ("template-id %qD in declaration of primary template",
1783 case tsk_invalid_member_spec:
1784 /* The error has already been reported in
1785 check_specialization_scope. */
1786 return error_mark_node;
1788 case tsk_invalid_expl_inst:
1789 error ("template parameter list used in explicit instantiation");
1795 error ("definition provided for explicit instantiation");
1797 explicit_instantiation = 1;
1800 case tsk_excessive_parms:
1801 case tsk_insufficient_parms:
1802 if (tsk == tsk_excessive_parms)
1803 error ("too many template parameter lists in declaration of %qD",
1805 else if (template_header_count)
1806 error("too few template parameter lists in declaration of %qD", decl);
1808 error("explicit specialization of %qD must be introduced by "
1809 "%<template <>%>", decl);
1813 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1815 member_specialization = 1;
1821 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1823 /* This case handles bogus declarations like template <>
1824 template <class T> void f<int>(); */
1826 if (uses_template_parms (declarator))
1827 error ("function template partial specialization %qD "
1828 "is not allowed", declarator);
1830 error ("template-id %qD in declaration of primary template",
1835 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1836 /* This is a specialization of a member template, without
1837 specialization the containing class. Something like:
1839 template <class T> struct S {
1840 template <class U> void f (U);
1842 template <> template <class U> void S<int>::f(U) {}
1844 That's a specialization -- but of the entire template. */
1852 if (specialization || member_specialization)
1854 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1855 for (; t; t = TREE_CHAIN (t))
1856 if (TREE_PURPOSE (t))
1859 ("default argument specified in explicit specialization");
1862 if (current_lang_name == lang_name_c)
1863 error ("template specialization with C linkage");
1866 if (specialization || member_specialization || explicit_instantiation)
1868 tree tmpl = NULL_TREE;
1869 tree targs = NULL_TREE;
1871 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1872 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1876 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
1881 /* If there is no class context, the explicit instantiation
1882 must be at namespace scope. */
1883 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
1885 /* Find the namespace binding, using the declaration
1887 fns = namespace_binding (dname, CP_DECL_CONTEXT (decl));
1888 if (!fns || !is_overloaded_fn (fns))
1890 error ("%qD is not a template function", dname);
1891 fns = error_mark_node;
1895 declarator = lookup_template_function (fns, NULL_TREE);
1898 if (declarator == error_mark_node)
1899 return error_mark_node;
1901 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1903 if (!explicit_instantiation)
1904 /* A specialization in class scope. This is invalid,
1905 but the error will already have been flagged by
1906 check_specialization_scope. */
1907 return error_mark_node;
1910 /* It's not valid to write an explicit instantiation in
1913 class C { template void f(); }
1915 This case is caught by the parser. However, on
1918 template class C { void f(); };
1920 (which is invalid) we can get here. The error will be
1927 else if (ctype != NULL_TREE
1928 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
1931 /* Find the list of functions in ctype that have the same
1932 name as the declared function. */
1933 tree name = TREE_OPERAND (declarator, 0);
1934 tree fns = NULL_TREE;
1937 if (constructor_name_p (name, ctype))
1939 int is_constructor = DECL_CONSTRUCTOR_P (decl);
1941 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
1942 : !CLASSTYPE_DESTRUCTORS (ctype))
1944 /* From [temp.expl.spec]:
1946 If such an explicit specialization for the member
1947 of a class template names an implicitly-declared
1948 special member function (clause _special_), the
1949 program is ill-formed.
1951 Similar language is found in [temp.explicit]. */
1952 error ("specialization of implicitly-declared special member function");
1953 return error_mark_node;
1956 name = is_constructor ? ctor_identifier : dtor_identifier;
1959 if (!DECL_CONV_FN_P (decl))
1961 idx = lookup_fnfields_1 (ctype, name);
1963 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
1967 VEC(tree,gc) *methods;
1970 /* For a type-conversion operator, we cannot do a
1971 name-based lookup. We might be looking for `operator
1972 int' which will be a specialization of `operator T'.
1973 So, we find *all* the conversion operators, and then
1974 select from them. */
1977 methods = CLASSTYPE_METHOD_VEC (ctype);
1979 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
1980 VEC_iterate (tree, methods, idx, ovl);
1983 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
1984 /* There are no more conversion functions. */
1987 /* Glue all these conversion functions together
1988 with those we already have. */
1989 for (; ovl; ovl = OVL_NEXT (ovl))
1990 fns = ovl_cons (OVL_CURRENT (ovl), fns);
1994 if (fns == NULL_TREE)
1996 error ("no member function %qD declared in %qT", name, ctype);
1997 return error_mark_node;
2000 TREE_OPERAND (declarator, 0) = fns;
2003 /* Figure out what exactly is being specialized at this point.
2004 Note that for an explicit instantiation, even one for a
2005 member function, we cannot tell apriori whether the
2006 instantiation is for a member template, or just a member
2007 function of a template class. Even if a member template is
2008 being instantiated, the member template arguments may be
2009 elided if they can be deduced from the rest of the
2011 tmpl = determine_specialization (declarator, decl,
2013 member_specialization,
2016 if (!tmpl || tmpl == error_mark_node)
2017 /* We couldn't figure out what this declaration was
2019 return error_mark_node;
2022 tree gen_tmpl = most_general_template (tmpl);
2024 if (explicit_instantiation)
2026 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2027 is done by do_decl_instantiation later. */
2029 int arg_depth = TMPL_ARGS_DEPTH (targs);
2030 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2032 if (arg_depth > parm_depth)
2034 /* If TMPL is not the most general template (for
2035 example, if TMPL is a friend template that is
2036 injected into namespace scope), then there will
2037 be too many levels of TARGS. Remove some of them
2042 new_targs = make_tree_vec (parm_depth);
2043 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2044 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2045 = TREE_VEC_ELT (targs, i);
2049 return instantiate_template (tmpl, targs, tf_error);
2052 /* If we thought that the DECL was a member function, but it
2053 turns out to be specializing a static member function,
2054 make DECL a static member function as well. */
2055 if (DECL_STATIC_FUNCTION_P (tmpl)
2056 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2057 revert_static_member_fn (decl);
2059 /* If this is a specialization of a member template of a
2060 template class. In we want to return the TEMPLATE_DECL,
2061 not the specialization of it. */
2062 if (tsk == tsk_template)
2064 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2065 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2068 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2069 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2070 = DECL_SOURCE_LOCATION (decl);
2071 /* We want to use the argument list specified in the
2072 definition, not in the original declaration. */
2073 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2074 = DECL_ARGUMENTS (decl);
2079 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2080 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2082 /* Inherit default function arguments from the template
2083 DECL is specializing. */
2084 copy_default_args_to_explicit_spec (decl);
2086 /* This specialization has the same protection as the
2087 template it specializes. */
2088 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2089 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2091 /* The specialization has the same visibility as the
2092 template it specializes. */
2093 if (DECL_VISIBILITY_SPECIFIED (gen_tmpl))
2095 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2096 DECL_VISIBILITY (decl) = DECL_VISIBILITY (gen_tmpl);
2099 if (is_friend && !have_def)
2100 /* This is not really a declaration of a specialization.
2101 It's just the name of an instantiation. But, it's not
2102 a request for an instantiation, either. */
2103 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2104 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2105 /* This is indeed a specialization. In case of constructors
2106 and destructors, we need in-charge and not-in-charge
2107 versions in V3 ABI. */
2108 clone_function_decl (decl, /*update_method_vec_p=*/0);
2110 /* Register this specialization so that we can find it
2112 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2119 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2120 parameters. These are represented in the same format used for
2121 DECL_TEMPLATE_PARMS. */
2124 comp_template_parms (tree parms1, tree parms2)
2129 if (parms1 == parms2)
2132 for (p1 = parms1, p2 = parms2;
2133 p1 != NULL_TREE && p2 != NULL_TREE;
2134 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2136 tree t1 = TREE_VALUE (p1);
2137 tree t2 = TREE_VALUE (p2);
2140 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2141 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2143 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2146 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2148 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2149 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2151 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2154 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2156 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2161 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2162 /* One set of parameters has more parameters lists than the
2169 /* Complain if DECL shadows a template parameter.
2171 [temp.local]: A template-parameter shall not be redeclared within its
2172 scope (including nested scopes). */
2175 check_template_shadow (tree decl)
2179 /* If we're not in a template, we can't possibly shadow a template
2181 if (!current_template_parms)
2184 /* Figure out what we're shadowing. */
2185 if (TREE_CODE (decl) == OVERLOAD)
2186 decl = OVL_CURRENT (decl);
2187 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2189 /* If there's no previous binding for this name, we're not shadowing
2190 anything, let alone a template parameter. */
2194 /* If we're not shadowing a template parameter, we're done. Note
2195 that OLDDECL might be an OVERLOAD (or perhaps even an
2196 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2198 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2201 /* We check for decl != olddecl to avoid bogus errors for using a
2202 name inside a class. We check TPFI to avoid duplicate errors for
2203 inline member templates. */
2205 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2208 error ("declaration of %q+#D", decl);
2209 error (" shadows template parm %q+#D", olddecl);
2212 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2213 ORIG_LEVEL, DECL, and TYPE. */
2216 build_template_parm_index (int index,
2222 tree t = make_node (TEMPLATE_PARM_INDEX);
2223 TEMPLATE_PARM_IDX (t) = index;
2224 TEMPLATE_PARM_LEVEL (t) = level;
2225 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2226 TEMPLATE_PARM_DECL (t) = decl;
2227 TREE_TYPE (t) = type;
2228 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2229 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2230 TREE_READONLY (t) = TREE_READONLY (decl);
2235 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2236 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2237 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2238 new one is created. */
2241 reduce_template_parm_level (tree index, tree type, int levels)
2243 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2244 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2245 != TEMPLATE_PARM_LEVEL (index) - levels))
2247 tree orig_decl = TEMPLATE_PARM_DECL (index);
2250 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2251 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2252 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2253 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2254 DECL_ARTIFICIAL (decl) = 1;
2255 SET_DECL_TEMPLATE_PARM_P (decl);
2257 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2258 TEMPLATE_PARM_LEVEL (index) - levels,
2259 TEMPLATE_PARM_ORIG_LEVEL (index),
2261 TEMPLATE_PARM_DESCENDANTS (index) = t;
2263 /* Template template parameters need this. */
2264 if (TREE_CODE (decl) != CONST_DECL)
2265 DECL_TEMPLATE_PARMS (decl)
2266 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2269 return TEMPLATE_PARM_DESCENDANTS (index);
2272 /* Process information from new template parameter NEXT and append it to the
2273 LIST being built. This new parameter is a non-type parameter iff
2274 IS_NON_TYPE is true. */
2277 process_template_parm (tree list, tree next, bool is_non_type)
2285 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2286 defval = TREE_PURPOSE (parm);
2290 tree p = TREE_VALUE (tree_last (list));
2292 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2293 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2295 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2303 parm = TREE_VALUE (parm);
2305 SET_DECL_TEMPLATE_PARM_P (parm);
2309 The top-level cv-qualifiers on the template-parameter are
2310 ignored when determining its type. */
2311 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2313 /* A template parameter is not modifiable. */
2314 TREE_CONSTANT (parm) = 1;
2315 TREE_INVARIANT (parm) = 1;
2316 TREE_READONLY (parm) = 1;
2317 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2318 TREE_TYPE (parm) = void_type_node;
2319 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2320 TREE_CONSTANT (decl) = 1;
2321 TREE_INVARIANT (decl) = 1;
2322 TREE_READONLY (decl) = 1;
2323 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2324 = build_template_parm_index (idx, processing_template_decl,
2325 processing_template_decl,
2326 decl, TREE_TYPE (parm));
2331 parm = TREE_VALUE (TREE_VALUE (parm));
2333 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2335 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2336 /* This is for distinguishing between real templates and template
2337 template parameters */
2338 TREE_TYPE (parm) = t;
2339 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2344 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2345 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2346 decl = build_decl (TYPE_DECL, parm, t);
2349 TYPE_NAME (t) = decl;
2350 TYPE_STUB_DECL (t) = decl;
2352 TEMPLATE_TYPE_PARM_INDEX (t)
2353 = build_template_parm_index (idx, processing_template_decl,
2354 processing_template_decl,
2355 decl, TREE_TYPE (parm));
2357 DECL_ARTIFICIAL (decl) = 1;
2358 SET_DECL_TEMPLATE_PARM_P (decl);
2360 parm = build_tree_list (defval, parm);
2361 return chainon (list, parm);
2364 /* The end of a template parameter list has been reached. Process the
2365 tree list into a parameter vector, converting each parameter into a more
2366 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2370 end_template_parm_list (tree parms)
2374 tree saved_parmlist = make_tree_vec (list_length (parms));
2376 current_template_parms
2377 = tree_cons (size_int (processing_template_decl),
2378 saved_parmlist, current_template_parms);
2380 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2382 next = TREE_CHAIN (parm);
2383 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2384 TREE_CHAIN (parm) = NULL_TREE;
2387 --processing_template_parmlist;
2389 return saved_parmlist;
2392 /* end_template_decl is called after a template declaration is seen. */
2395 end_template_decl (void)
2397 reset_specialization ();
2399 if (! processing_template_decl)
2402 /* This matches the pushlevel in begin_template_parm_list. */
2405 --processing_template_decl;
2406 current_template_parms = TREE_CHAIN (current_template_parms);
2409 /* Given a template argument vector containing the template PARMS.
2410 The innermost PARMS are given first. */
2413 current_template_args (void)
2416 tree args = NULL_TREE;
2417 int length = TMPL_PARMS_DEPTH (current_template_parms);
2420 /* If there is only one level of template parameters, we do not
2421 create a TREE_VEC of TREE_VECs. Instead, we return a single
2422 TREE_VEC containing the arguments. */
2424 args = make_tree_vec (length);
2426 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2428 tree a = copy_node (TREE_VALUE (header));
2431 TREE_TYPE (a) = NULL_TREE;
2432 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2434 tree t = TREE_VEC_ELT (a, i);
2436 /* T will be a list if we are called from within a
2437 begin/end_template_parm_list pair, but a vector directly
2438 if within a begin/end_member_template_processing pair. */
2439 if (TREE_CODE (t) == TREE_LIST)
2443 if (TREE_CODE (t) == TYPE_DECL
2444 || TREE_CODE (t) == TEMPLATE_DECL)
2447 t = DECL_INITIAL (t);
2448 TREE_VEC_ELT (a, i) = t;
2453 TREE_VEC_ELT (args, --l) = a;
2461 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2462 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
2463 a member template. Used by push_template_decl below. */
2466 build_template_decl (tree decl, tree parms, bool member_template_p)
2468 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2469 DECL_TEMPLATE_PARMS (tmpl) = parms;
2470 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2471 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
2472 if (DECL_LANG_SPECIFIC (decl))
2474 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2475 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2476 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2477 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2478 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2479 if (DECL_OVERLOADED_OPERATOR_P (decl))
2480 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2481 DECL_OVERLOADED_OPERATOR_P (decl));
2487 struct template_parm_data
2489 /* The level of the template parameters we are currently
2493 /* The index of the specialization argument we are currently
2497 /* An array whose size is the number of template parameters. The
2498 elements are nonzero if the parameter has been used in any one
2499 of the arguments processed so far. */
2502 /* An array whose size is the number of template arguments. The
2503 elements are nonzero if the argument makes use of template
2504 parameters of this level. */
2505 int* arg_uses_template_parms;
2508 /* Subroutine of push_template_decl used to see if each template
2509 parameter in a partial specialization is used in the explicit
2510 argument list. If T is of the LEVEL given in DATA (which is
2511 treated as a template_parm_data*), then DATA->PARMS is marked
2515 mark_template_parm (tree t, void* data)
2519 struct template_parm_data* tpd = (struct template_parm_data*) data;
2521 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2523 level = TEMPLATE_PARM_LEVEL (t);
2524 idx = TEMPLATE_PARM_IDX (t);
2528 level = TEMPLATE_TYPE_LEVEL (t);
2529 idx = TEMPLATE_TYPE_IDX (t);
2532 if (level == tpd->level)
2534 tpd->parms[idx] = 1;
2535 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2538 /* Return zero so that for_each_template_parm will continue the
2539 traversal of the tree; we want to mark *every* template parm. */
2543 /* Process the partial specialization DECL. */
2546 process_partial_specialization (tree decl)
2548 tree type = TREE_TYPE (decl);
2549 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2550 tree specargs = CLASSTYPE_TI_ARGS (type);
2551 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2552 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2553 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2554 int nargs = TREE_VEC_LENGTH (inner_args);
2555 int ntparms = TREE_VEC_LENGTH (inner_parms);
2557 int did_error_intro = 0;
2558 struct template_parm_data tpd;
2559 struct template_parm_data tpd2;
2561 /* We check that each of the template parameters given in the
2562 partial specialization is used in the argument list to the
2563 specialization. For example:
2565 template <class T> struct S;
2566 template <class T> struct S<T*>;
2568 The second declaration is OK because `T*' uses the template
2569 parameter T, whereas
2571 template <class T> struct S<int>;
2573 is no good. Even trickier is:
2584 The S2<T> declaration is actually invalid; it is a
2585 full-specialization. Of course,
2588 struct S2<T (*)(U)>;
2590 or some such would have been OK. */
2591 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2592 tpd.parms = alloca (sizeof (int) * ntparms);
2593 memset (tpd.parms, 0, sizeof (int) * ntparms);
2595 tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
2596 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2597 for (i = 0; i < nargs; ++i)
2599 tpd.current_arg = i;
2600 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2601 &mark_template_parm,
2605 for (i = 0; i < ntparms; ++i)
2606 if (tpd.parms[i] == 0)
2608 /* One of the template parms was not used in the
2610 if (!did_error_intro)
2612 error ("template parameters not used in partial specialization:");
2613 did_error_intro = 1;
2616 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2619 /* [temp.class.spec]
2621 The argument list of the specialization shall not be identical to
2622 the implicit argument list of the primary template. */
2623 if (comp_template_args
2625 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2627 error ("partial specialization %qT does not specialize any template arguments", type);
2629 /* [temp.class.spec]
2631 A partially specialized non-type argument expression shall not
2632 involve template parameters of the partial specialization except
2633 when the argument expression is a simple identifier.
2635 The type of a template parameter corresponding to a specialized
2636 non-type argument shall not be dependent on a parameter of the
2638 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
2640 for (i = 0; i < nargs; ++i)
2642 tree arg = TREE_VEC_ELT (inner_args, i);
2643 if (/* These first two lines are the `non-type' bit. */
2645 && TREE_CODE (arg) != TEMPLATE_DECL
2646 /* This next line is the `argument expression is not just a
2647 simple identifier' condition and also the `specialized
2648 non-type argument' bit. */
2649 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2651 if (tpd.arg_uses_template_parms[i])
2652 error ("template argument %qE involves template parameter(s)", arg);
2655 /* Look at the corresponding template parameter,
2656 marking which template parameters its type depends
2659 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2664 /* We haven't yet initialized TPD2. Do so now. */
2665 tpd2.arg_uses_template_parms
2666 = alloca (sizeof (int) * nargs);
2667 /* The number of parameters here is the number in the
2668 main template, which, as checked in the assertion
2670 tpd2.parms = alloca (sizeof (int) * nargs);
2672 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2675 /* Mark the template parameters. But this time, we're
2676 looking for the template parameters of the main
2677 template, not in the specialization. */
2678 tpd2.current_arg = i;
2679 tpd2.arg_uses_template_parms[i] = 0;
2680 memset (tpd2.parms, 0, sizeof (int) * nargs);
2681 for_each_template_parm (type,
2682 &mark_template_parm,
2686 if (tpd2.arg_uses_template_parms [i])
2688 /* The type depended on some template parameters.
2689 If they are fully specialized in the
2690 specialization, that's OK. */
2692 for (j = 0; j < nargs; ++j)
2693 if (tpd2.parms[j] != 0
2694 && tpd.arg_uses_template_parms [j])
2696 error ("type %qT of template argument %qE depends "
2697 "on template parameter(s)",
2707 if (retrieve_specialization (maintmpl, specargs,
2708 /*class_specializations_p=*/true))
2709 /* We've already got this specialization. */
2712 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2713 = tree_cons (inner_args, inner_parms,
2714 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2715 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2719 /* Check that a template declaration's use of default arguments is not
2720 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2721 nonzero if DECL is the thing declared by a primary template.
2722 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2725 check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2728 int last_level_to_check;
2733 A default template-argument shall not be specified in a
2734 function template declaration or a function template definition, nor
2735 in the template-parameter-list of the definition of a member of a
2738 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2739 /* You can't have a function template declaration in a local
2740 scope, nor you can you define a member of a class template in a
2744 if (current_class_type
2745 && !TYPE_BEING_DEFINED (current_class_type)
2746 && DECL_LANG_SPECIFIC (decl)
2747 /* If this is either a friend defined in the scope of the class
2748 or a member function. */
2749 && (DECL_FUNCTION_MEMBER_P (decl)
2750 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2751 : DECL_FRIEND_CONTEXT (decl)
2752 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2754 /* And, if it was a member function, it really was defined in
2755 the scope of the class. */
2756 && (!DECL_FUNCTION_MEMBER_P (decl)
2757 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2758 /* We already checked these parameters when the template was
2759 declared, so there's no need to do it again now. This function
2760 was defined in class scope, but we're processing it's body now
2761 that the class is complete. */
2766 If a template-parameter has a default template-argument, all
2767 subsequent template-parameters shall have a default
2768 template-argument supplied. */
2769 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2771 tree inner_parms = TREE_VALUE (parm_level);
2772 int ntparms = TREE_VEC_LENGTH (inner_parms);
2773 int seen_def_arg_p = 0;
2776 for (i = 0; i < ntparms; ++i)
2778 tree parm = TREE_VEC_ELT (inner_parms, i);
2779 if (TREE_PURPOSE (parm))
2781 else if (seen_def_arg_p)
2783 error ("no default argument for %qD", TREE_VALUE (parm));
2784 /* For better subsequent error-recovery, we indicate that
2785 there should have been a default argument. */
2786 TREE_PURPOSE (parm) = error_mark_node;
2791 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2792 /* For an ordinary class template, default template arguments are
2793 allowed at the innermost level, e.g.:
2794 template <class T = int>
2796 but, in a partial specialization, they're not allowed even
2797 there, as we have in [temp.class.spec]:
2799 The template parameter list of a specialization shall not
2800 contain default template argument values.
2802 So, for a partial specialization, or for a function template,
2803 we look at all of them. */
2806 /* But, for a primary class template that is not a partial
2807 specialization we look at all template parameters except the
2809 parms = TREE_CHAIN (parms);
2811 /* Figure out what error message to issue. */
2812 if (TREE_CODE (decl) == FUNCTION_DECL)
2813 msg = "default template arguments may not be used in function templates";
2814 else if (is_partial)
2815 msg = "default template arguments may not be used in partial specializations";
2817 msg = "default argument for template parameter for class enclosing %qD";
2819 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2820 /* If we're inside a class definition, there's no need to
2821 examine the parameters to the class itself. On the one
2822 hand, they will be checked when the class is defined, and,
2823 on the other, default arguments are valid in things like:
2824 template <class T = double>
2825 struct S { template <class U> void f(U); };
2826 Here the default argument for `S' has no bearing on the
2827 declaration of `f'. */
2828 last_level_to_check = template_class_depth (current_class_type) + 1;
2830 /* Check everything. */
2831 last_level_to_check = 0;
2833 for (parm_level = parms;
2834 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2835 parm_level = TREE_CHAIN (parm_level))
2837 tree inner_parms = TREE_VALUE (parm_level);
2841 ntparms = TREE_VEC_LENGTH (inner_parms);
2842 for (i = 0; i < ntparms; ++i)
2843 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2851 /* Clear out the default argument so that we are not
2853 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2856 /* At this point, if we're still interested in issuing messages,
2857 they must apply to classes surrounding the object declared. */
2859 msg = "default argument for template parameter for class enclosing %qD";
2863 /* Worker for push_template_decl_real, called via
2864 for_each_template_parm. DATA is really an int, indicating the
2865 level of the parameters we are interested in. If T is a template
2866 parameter of that level, return nonzero. */
2869 template_parm_this_level_p (tree t, void* data)
2871 int this_level = *(int *)data;
2874 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2875 level = TEMPLATE_PARM_LEVEL (t);
2877 level = TEMPLATE_TYPE_LEVEL (t);
2878 return level == this_level;
2881 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2882 parameters given by current_template_args, or reuses a
2883 previously existing one, if appropriate. Returns the DECL, or an
2884 equivalent one, if it is replaced via a call to duplicate_decls.
2886 If IS_FRIEND is true, DECL is a friend declaration. */
2889 push_template_decl_real (tree decl, bool is_friend)
2897 int new_template_p = 0;
2898 /* True if the template is a member template, in the sense of
2900 bool member_template_p = false;
2902 if (decl == error_mark_node)
2905 /* See if this is a partial specialization. */
2906 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
2907 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
2908 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
2910 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
2914 /* For a friend, we want the context of the friend function, not
2915 the type of which it is a friend. */
2916 ctx = DECL_CONTEXT (decl);
2917 else if (CP_DECL_CONTEXT (decl)
2918 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
2919 /* In the case of a virtual function, we want the class in which
2921 ctx = CP_DECL_CONTEXT (decl);
2923 /* Otherwise, if we're currently defining some class, the DECL
2924 is assumed to be a member of the class. */
2925 ctx = current_scope ();
2927 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
2930 if (!DECL_CONTEXT (decl))
2931 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2933 /* See if this is a primary template. */
2934 primary = template_parm_scope_p ();
2938 if (DECL_CLASS_SCOPE_P (decl))
2939 member_template_p = true;
2940 if (current_lang_name == lang_name_c)
2941 error ("template with C linkage");
2942 else if (TREE_CODE (decl) == TYPE_DECL
2943 && ANON_AGGRNAME_P (DECL_NAME (decl)))
2944 error ("template class without a name");
2945 else if (TREE_CODE (decl) == FUNCTION_DECL)
2947 if (DECL_DESTRUCTOR_P (decl))
2951 A destructor shall not be a member template. */
2952 error ("destructor %qD declared as member template", decl);
2953 return error_mark_node;
2955 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
2956 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
2957 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
2958 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
2959 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
2960 == void_list_node)))
2962 /* [basic.stc.dynamic.allocation]
2964 An allocation function can be a function
2965 template. ... Template allocation functions shall
2966 have two or more parameters. */
2967 error ("invalid template declaration of %qD", decl);
2971 else if ((DECL_IMPLICIT_TYPEDEF_P (decl)
2972 && CLASS_TYPE_P (TREE_TYPE (decl)))
2973 || (TREE_CODE (decl) == VAR_DECL && ctx && CLASS_TYPE_P (ctx)))
2977 error ("template declaration of %q#D", decl);
2978 return error_mark_node;
2982 /* Check to see that the rules regarding the use of default
2983 arguments are not being violated. */
2984 check_default_tmpl_args (decl, current_template_parms,
2985 primary, is_partial);
2988 return process_partial_specialization (decl);
2990 args = current_template_args ();
2993 || TREE_CODE (ctx) == FUNCTION_DECL
2994 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
2995 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
2997 if (DECL_LANG_SPECIFIC (decl)
2998 && DECL_TEMPLATE_INFO (decl)
2999 && DECL_TI_TEMPLATE (decl))
3000 tmpl = DECL_TI_TEMPLATE (decl);
3001 /* If DECL is a TYPE_DECL for a class-template, then there won't
3002 be DECL_LANG_SPECIFIC. The information equivalent to
3003 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3004 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3005 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3006 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3008 /* Since a template declaration already existed for this
3009 class-type, we must be redeclaring it here. Make sure
3010 that the redeclaration is valid. */
3011 redeclare_class_template (TREE_TYPE (decl),
3012 current_template_parms);
3013 /* We don't need to create a new TEMPLATE_DECL; just use the
3014 one we already had. */
3015 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3019 tmpl = build_template_decl (decl, current_template_parms,
3023 if (DECL_LANG_SPECIFIC (decl)
3024 && DECL_TEMPLATE_SPECIALIZATION (decl))
3026 /* A specialization of a member template of a template
3028 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3029 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3030 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3036 tree a, t, current, parms;
3039 if (TREE_CODE (decl) == TYPE_DECL)
3041 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
3042 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
3043 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3044 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3045 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3048 error ("%qD does not declare a template type", decl);
3052 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
3054 error ("template definition of non-template %q#D", decl);
3058 tmpl = DECL_TI_TEMPLATE (decl);
3060 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3061 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3062 && DECL_TEMPLATE_SPECIALIZATION (decl)
3063 && DECL_MEMBER_TEMPLATE_P (tmpl))
3067 /* The declaration is a specialization of a member
3068 template, declared outside the class. Therefore, the
3069 innermost template arguments will be NULL, so we
3070 replace them with the arguments determined by the
3071 earlier call to check_explicit_specialization. */
3072 args = DECL_TI_ARGS (decl);
3075 = build_template_decl (decl, current_template_parms,
3077 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3078 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3079 DECL_TI_TEMPLATE (decl) = new_tmpl;
3080 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3081 DECL_TEMPLATE_INFO (new_tmpl)
3082 = tree_cons (tmpl, args, NULL_TREE);
3084 register_specialization (new_tmpl,
3085 most_general_template (tmpl),
3091 /* Make sure the template headers we got make sense. */
3093 parms = DECL_TEMPLATE_PARMS (tmpl);
3094 i = TMPL_PARMS_DEPTH (parms);
3095 if (TMPL_ARGS_DEPTH (args) != i)
3097 error ("expected %d levels of template parms for %q#D, got %d",
3098 i, decl, TMPL_ARGS_DEPTH (args));
3101 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3103 a = TMPL_ARGS_LEVEL (args, i);
3104 t = INNERMOST_TEMPLATE_PARMS (parms);
3106 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3108 if (current == decl)
3109 error ("got %d template parameters for %q#D",
3110 TREE_VEC_LENGTH (a), decl);
3112 error ("got %d template parameters for %q#T",
3113 TREE_VEC_LENGTH (a), current);
3114 error (" but %d required", TREE_VEC_LENGTH (t));
3115 return error_mark_node;
3118 /* Perhaps we should also check that the parms are used in the
3119 appropriate qualifying scopes in the declarator? */
3121 if (current == decl)
3124 current = TYPE_CONTEXT (current);
3128 DECL_TEMPLATE_RESULT (tmpl) = decl;
3129 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3131 /* Push template declarations for global functions and types. Note
3132 that we do not try to push a global template friend declared in a
3133 template class; such a thing may well depend on the template
3134 parameters of the class. */
3135 if (new_template_p && !ctx
3136 && !(is_friend && template_class_depth (current_class_type) > 0))
3138 tmpl = pushdecl_namespace_level (tmpl, is_friend);
3139 if (tmpl == error_mark_node)
3140 return error_mark_node;
3142 /* Hide template friend classes that haven't been declared yet. */
3143 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
3145 DECL_ANTICIPATED (tmpl) = 1;
3146 DECL_FRIEND_P (tmpl) = 1;
3152 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3153 if (DECL_CONV_FN_P (tmpl))
3155 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3157 /* It is a conversion operator. See if the type converted to
3158 depends on innermost template operands. */
3160 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3162 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3166 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3167 back to its most general template. If TMPL is a specialization,
3168 ARGS may only have the innermost set of arguments. Add the missing
3169 argument levels if necessary. */
3170 if (DECL_TEMPLATE_INFO (tmpl))
3171 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3173 info = tree_cons (tmpl, args, NULL_TREE);
3175 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3177 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3178 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
3179 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3180 /* Don't change the name if we've already set it up. */
3181 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
3182 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
3184 else if (DECL_LANG_SPECIFIC (decl))
3185 DECL_TEMPLATE_INFO (decl) = info;
3187 return DECL_TEMPLATE_RESULT (tmpl);
3191 push_template_decl (tree decl)
3193 return push_template_decl_real (decl, false);
3196 /* Called when a class template TYPE is redeclared with the indicated
3197 template PARMS, e.g.:
3199 template <class T> struct S;
3200 template <class T> struct S {}; */
3203 redeclare_class_template (tree type, tree parms)
3209 if (!TYPE_TEMPLATE_INFO (type))
3211 error ("%qT is not a template type", type);
3215 tmpl = TYPE_TI_TEMPLATE (type);
3216 if (!PRIMARY_TEMPLATE_P (tmpl))
3217 /* The type is nested in some template class. Nothing to worry
3218 about here; there are no new template parameters for the nested
3224 error ("template specifiers not specified in declaration of %qD",
3229 parms = INNERMOST_TEMPLATE_PARMS (parms);
3230 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3232 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3234 error ("previous declaration %q+D", tmpl);
3235 error ("used %d template parameter(s) instead of %d",
3236 TREE_VEC_LENGTH (tmpl_parms),
3237 TREE_VEC_LENGTH (parms));
3241 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3243 tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3244 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3245 tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3246 tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3248 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
3250 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
3251 || (TREE_CODE (tmpl_parm) != TYPE_DECL
3252 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm))))
3254 error ("template parameter %q+#D", tmpl_parm);
3255 error ("redeclared here as %q#D", parm);
3259 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3261 /* We have in [temp.param]:
3263 A template-parameter may not be given default arguments
3264 by two different declarations in the same scope. */
3265 error ("redefinition of default argument for %q#D", parm);
3266 error ("%J original definition appeared here", tmpl_parm);
3270 if (parm_default != NULL_TREE)
3271 /* Update the previous template parameters (which are the ones
3272 that will really count) with the new default value. */
3273 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3274 else if (tmpl_default != NULL_TREE)
3275 /* Update the new parameters, too; they'll be used as the
3276 parameters for any members. */
3277 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3281 /* Simplify EXPR if it is a non-dependent expression. Returns the
3282 (possibly simplified) expression. */
3285 fold_non_dependent_expr (tree expr)
3287 /* If we're in a template, but EXPR isn't value dependent, simplify
3288 it. We're supposed to treat:
3290 template <typename T> void f(T[1 + 1]);
3291 template <typename T> void f(T[2]);
3293 as two declarations of the same function, for example. */
3294 if (processing_template_decl
3295 && !type_dependent_expression_p (expr)
3296 && !value_dependent_expression_p (expr))
3298 HOST_WIDE_INT saved_processing_template_decl;
3300 saved_processing_template_decl = processing_template_decl;
3301 processing_template_decl = 0;
3302 expr = tsubst_copy_and_build (expr,
3305 /*in_decl=*/NULL_TREE,
3306 /*function_p=*/false);
3307 processing_template_decl = saved_processing_template_decl;
3312 /* EXPR is an expression which is used in a constant-expression context.
3313 For instance, it could be a VAR_DECL with a constant initializer.
3314 Extract the innest constant expression.
3316 This is basically a more powerful version of
3317 integral_constant_value, which can be used also in templates where
3318 initializers can maintain a syntactic rather than semantic form
3319 (even if they are non-dependent, for access-checking purposes). */
3322 fold_decl_constant_value (tree expr)
3324 tree const_expr = expr;
3327 expr = fold_non_dependent_expr (const_expr);
3328 const_expr = integral_constant_value (expr);
3330 while (expr != const_expr);
3335 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
3336 must be a function or a pointer-to-function type, as specified
3337 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
3338 and check that the resulting function has external linkage. */
3341 convert_nontype_argument_function (tree type, tree expr)
3346 fn = instantiate_type (type, fns, tf_none);
3347 if (fn == error_mark_node)
3348 return error_mark_node;
3351 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
3352 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
3354 /* [temp.arg.nontype]/1
3356 A template-argument for a non-type, non-template template-parameter
3359 -- the address of an object or function with external linkage. */
3360 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
3362 error ("%qE is not a valid template argument for type %qT "
3363 "because function %qD has not external linkage",
3364 expr, type, fn_no_ptr);
3371 /* Attempt to convert the non-type template parameter EXPR to the
3372 indicated TYPE. If the conversion is successful, return the
3373 converted value. If the conversion is unsuccessful, return
3374 NULL_TREE if we issued an error message, or error_mark_node if we
3375 did not. We issue error messages for out-and-out bad template
3376 parameters, but not simply because the conversion failed, since we
3377 might be just trying to do argument deduction. Both TYPE and EXPR
3378 must be non-dependent.
3380 The conversion follows the special rules described in
3381 [temp.arg.nontype], and it is much more strict than an implicit
3384 This function is called twice for each template argument (see
3385 lookup_template_class for a more accurate description of this
3386 problem). This means that we need to handle expressions which
3387 are not valid in a C++ source, but can be created from the
3388 first call (for instance, casts to perform conversions). These
3389 hacks can go away after we fix the double coercion problem. */
3392 convert_nontype_argument (tree type, tree expr)
3396 /* Detect immediately string literals as invalid non-type argument.
3397 This special-case is not needed for correctness (we would easily
3398 catch this later), but only to provide better diagnostic for this
3399 common user mistake. As suggested by DR 100, we do not mention
3400 linkage issues in the diagnostic as this is not the point. */
3401 if (TREE_CODE (expr) == STRING_CST)
3403 error ("%qE is not a valid template argument for type %qT "
3404 "because string literals can never be used in this context",
3409 /* If we are in a template, EXPR may be non-dependent, but still
3410 have a syntactic, rather than semantic, form. For example, EXPR
3411 might be a SCOPE_REF, rather than the VAR_DECL to which the
3412 SCOPE_REF refers. Preserving the qualifying scope is necessary
3413 so that access checking can be performed when the template is
3414 instantiated -- but here we need the resolved form so that we can
3415 convert the argument. */
3416 expr = fold_non_dependent_expr (expr);
3417 expr_type = TREE_TYPE (expr);
3419 /* HACK: Due to double coercion, we can get a
3420 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
3421 which is the tree that we built on the first call (see
3422 below when coercing to reference to object or to reference to
3423 function). We just strip everything and get to the arg.
3424 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
3426 if (TREE_CODE (expr) == NOP_EXPR)
3428 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
3430 /* ??? Maybe we could use convert_from_reference here, but we
3431 would need to relax its constraints because the NOP_EXPR
3432 could actually change the type to something more cv-qualified,
3433 and this is not folded by convert_from_reference. */
3434 tree addr = TREE_OPERAND (expr, 0);
3435 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
3436 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
3437 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
3438 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3439 (TREE_TYPE (expr_type),
3440 TREE_TYPE (TREE_TYPE (addr))));
3442 expr = TREE_OPERAND (addr, 0);
3443 expr_type = TREE_TYPE (expr);
3446 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
3447 parameter is a pointer to object, through decay and
3448 qualification conversion. Let's strip everything. */
3449 else if (TYPE_PTROBV_P (type))
3452 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
3453 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
3454 /* Skip the ADDR_EXPR only if it is part of the decay for
3455 an array. Otherwise, it is part of the original argument
3456 in the source code. */
3457 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
3458 expr = TREE_OPERAND (expr, 0);
3459 expr_type = TREE_TYPE (expr);
3463 /* [temp.arg.nontype]/5, bullet 1
3465 For a non-type template-parameter of integral or enumeration type,
3466 integral promotions (_conv.prom_) and integral conversions
3467 (_conv.integral_) are applied. */
3468 if (INTEGRAL_TYPE_P (type))
3470 if (!INTEGRAL_TYPE_P (expr_type))
3471 return error_mark_node;
3473 expr = fold_decl_constant_value (expr);
3474 /* Notice that there are constant expressions like '4 % 0' which
3475 do not fold into integer constants. */
3476 if (TREE_CODE (expr) != INTEGER_CST)
3478 error ("%qE is not a valid template argument for type %qT "
3479 "because it is a non-constant expression", expr, type);
3483 /* At this point, an implicit conversion does what we want,
3484 because we already know that the expression is of integral
3486 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
3487 if (expr == error_mark_node)
3488 return error_mark_node;
3490 /* Conversion was allowed: fold it to a bare integer constant. */
3493 /* [temp.arg.nontype]/5, bullet 2
3495 For a non-type template-parameter of type pointer to object,
3496 qualification conversions (_conv.qual_) and the array-to-pointer
3497 conversion (_conv.array_) are applied. */
3498 else if (TYPE_PTROBV_P (type))
3500 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
3502 A template-argument for a non-type, non-template template-parameter
3503 shall be one of: [...]
3505 -- the name of a non-type template-parameter;
3506 -- the address of an object or function with external linkage, [...]
3507 expressed as "& id-expression" where the & is optional if the name
3508 refers to a function or array, or if the corresponding
3509 template-parameter is a reference.
3511 Here, we do not care about functions, as they are invalid anyway
3512 for a parameter of type pointer-to-object. */
3513 bool constant_address_p =
3514 (TREE_CODE (expr) == ADDR_EXPR
3515 || TREE_CODE (expr_type) == ARRAY_TYPE
3516 || (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr)));
3518 expr = decay_conversion (expr);
3519 if (expr == error_mark_node)
3520 return error_mark_node;
3522 expr = perform_qualification_conversions (type, expr);
3523 if (expr == error_mark_node)
3524 return error_mark_node;
3526 if (!constant_address_p)
3528 error ("%qE is not a valid template argument for type %qT "
3529 "because it is not a constant pointer", expr, type);
3533 /* [temp.arg.nontype]/5, bullet 3
3535 For a non-type template-parameter of type reference to object, no
3536 conversions apply. The type referred to by the reference may be more
3537 cv-qualified than the (otherwise identical) type of the
3538 template-argument. The template-parameter is bound directly to the
3539 template-argument, which must be an lvalue. */
3540 else if (TYPE_REF_OBJ_P (type))
3542 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
3544 return error_mark_node;
3546 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
3548 error ("%qE is not a valid template argument for type %qT "
3549 "because of conflicts in cv-qualification", expr, type);
3553 if (!real_lvalue_p (expr))
3555 error ("%qE is not a valid template argument for type %qT "
3556 "because it is not a lvalue", expr, type);
3560 /* [temp.arg.nontype]/1
3562 A template-argument for a non-type, non-template template-parameter
3563 shall be one of: [...]
3565 -- the address of an object or function with external linkage. */
3566 if (!DECL_EXTERNAL_LINKAGE_P (expr))
3568 error ("%qE is not a valid template argument for type %qT "
3569 "because object %qD has not external linkage",
3574 expr = build_nop (type, build_address (expr));
3576 /* [temp.arg.nontype]/5, bullet 4
3578 For a non-type template-parameter of type pointer to function, only
3579 the function-to-pointer conversion (_conv.func_) is applied. If the
3580 template-argument represents a set of overloaded functions (or a
3581 pointer to such), the matching function is selected from the set
3583 else if (TYPE_PTRFN_P (type))
3585 /* If the argument is a template-id, we might not have enough
3586 context information to decay the pointer.
3587 ??? Why static5.C requires decay and subst1.C works fine
3589 if (!type_unknown_p (expr_type))
3591 expr = decay_conversion (expr);
3592 if (expr == error_mark_node)
3593 return error_mark_node;
3596 expr = convert_nontype_argument_function (type, expr);
3597 if (!expr || expr == error_mark_node)
3600 /* [temp.arg.nontype]/5, bullet 5
3602 For a non-type template-parameter of type reference to function, no
3603 conversions apply. If the template-argument represents a set of
3604 overloaded functions, the matching function is selected from the set
3606 else if (TYPE_REFFN_P (type))
3608 if (TREE_CODE (expr) == ADDR_EXPR)
3610 error ("%qE is not a valid template argument for type %qT "
3611 "because it is a pointer", expr, type);
3612 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
3616 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
3617 if (!expr || expr == error_mark_node)
3620 expr = build_nop (type, build_address (expr));
3622 /* [temp.arg.nontype]/5, bullet 6
3624 For a non-type template-parameter of type pointer to member function,
3625 no conversions apply. If the template-argument represents a set of
3626 overloaded member functions, the matching member function is selected
3627 from the set (_over.over_). */
3628 else if (TYPE_PTRMEMFUNC_P (type))
3630 expr = instantiate_type (type, expr, tf_none);
3631 if (expr == error_mark_node)
3632 return error_mark_node;
3634 /* There is no way to disable standard conversions in
3635 resolve_address_of_overloaded_function (called by
3636 instantiate_type). It is possible that the call succeeded by
3637 converting &B::I to &D::I (where B is a base of D), so we need
3638 to reject this conversion here.
3640 Actually, even if there was a way to disable standard conversions,
3641 it would still be better to reject them here so that we can
3642 provide a superior diagnostic. */
3643 if (!same_type_p (TREE_TYPE (expr), type))
3645 /* Make sure we are just one standard conversion off. */
3646 gcc_assert (can_convert (type, TREE_TYPE (expr)));
3647 error ("%qE is not a valid template argument for type %qT "
3648 "because it is of type %qT", expr, type,
3650 inform ("standard conversions are not allowed in this context");
3654 /* [temp.arg.nontype]/5, bullet 7
3656 For a non-type template-parameter of type pointer to data member,
3657 qualification conversions (_conv.qual_) are applied. */
3658 else if (TYPE_PTRMEM_P (type))
3660 expr = perform_qualification_conversions (type, expr);
3661 if (expr == error_mark_node)
3664 /* A template non-type parameter must be one of the above. */
3668 /* Sanity check: did we actually convert the argument to the
3670 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
3675 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3676 template template parameters. Both PARM_PARMS and ARG_PARMS are
3677 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3680 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3681 the case, then extra parameters must have default arguments.
3683 Consider the example:
3684 template <class T, class Allocator = allocator> class vector;
3685 template<template <class U> class TT> class C;
3687 C<vector> is a valid instantiation. PARM_PARMS for the above code
3688 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3689 T and Allocator) and OUTER_ARGS contains the argument that is used to
3690 substitute the TT parameter. */
3693 coerce_template_template_parms (tree parm_parms,
3695 tsubst_flags_t complain,
3699 int nparms, nargs, i;
3702 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
3703 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
3705 nparms = TREE_VEC_LENGTH (parm_parms);
3706 nargs = TREE_VEC_LENGTH (arg_parms);
3708 /* The rule here is opposite of coerce_template_parms. */
3711 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE))
3714 for (i = 0; i < nparms; ++i)
3716 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3717 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3719 if (arg == NULL_TREE || arg == error_mark_node
3720 || parm == NULL_TREE || parm == error_mark_node)
3723 if (TREE_CODE (arg) != TREE_CODE (parm))
3726 switch (TREE_CODE (parm))
3732 /* We encounter instantiations of templates like
3733 template <template <template <class> class> class TT>
3736 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3737 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3739 if (!coerce_template_template_parms
3740 (parmparm, argparm, complain, in_decl, outer_args))
3746 /* The tsubst call is used to handle cases such as
3748 template <int> class C {};
3749 template <class T, template <T> class TT> class D {};
3752 i.e. the parameter list of TT depends on earlier parameters. */
3753 if (!dependent_type_p (TREE_TYPE (arg))
3755 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3767 /* Convert the indicated template ARG as necessary to match the
3768 indicated template PARM. Returns the converted ARG, or
3769 error_mark_node if the conversion was unsuccessful. Error and
3770 warning messages are issued under control of COMPLAIN. This
3771 conversion is for the Ith parameter in the parameter list. ARGS is
3772 the full set of template arguments deduced so far. */
3775 convert_template_argument (tree parm,
3778 tsubst_flags_t complain,
3784 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3786 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3788 if (TREE_CODE (arg) == TREE_LIST
3789 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3791 /* The template argument was the name of some
3792 member function. That's usually
3793 invalid, but static members are OK. In any
3794 case, grab the underlying fields/functions
3795 and issue an error later if required. */
3796 arg = TREE_VALUE (arg);
3797 TREE_TYPE (arg) = unknown_type_node;
3800 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3801 requires_type = (TREE_CODE (parm) == TYPE_DECL
3802 || requires_tmpl_type);
3804 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3805 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3806 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3807 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3810 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3811 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3812 arg = TYPE_STUB_DECL (arg);
3814 is_type = TYPE_P (arg) || is_tmpl_type;
3816 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3817 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3819 pedwarn ("to refer to a type member of a template parameter, "
3820 "use %<typename %E%>", arg);
3822 arg = make_typename_type (TREE_OPERAND (arg, 0),
3823 TREE_OPERAND (arg, 1),
3825 complain & tf_error);
3828 if (is_type != requires_type)
3832 if (complain & tf_error)
3834 error ("type/value mismatch at argument %d in template "
3835 "parameter list for %qD",
3838 error (" expected a constant of type %qT, got %qT",
3840 (is_tmpl_type ? DECL_NAME (arg) : arg));
3841 else if (requires_tmpl_type)
3842 error (" expected a class template, got %qE", arg);
3844 error (" expected a type, got %qE", arg);
3847 return error_mark_node;
3849 if (is_tmpl_type ^ requires_tmpl_type)
3851 if (in_decl && (complain & tf_error))
3853 error ("type/value mismatch at argument %d in template "
3854 "parameter list for %qD",
3857 error (" expected a type, got %qT", DECL_NAME (arg));
3859 error (" expected a class template, got %qT", arg);
3861 return error_mark_node;
3866 if (requires_tmpl_type)
3868 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
3869 /* The number of argument required is not known yet.
3870 Just accept it for now. */
3871 val = TREE_TYPE (arg);
3874 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3875 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3877 if (coerce_template_template_parms (parmparm, argparm,
3883 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3885 if (val != error_mark_node
3886 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
3887 val = TREE_TYPE (val);
3891 if (in_decl && (complain & tf_error))
3893 error ("type/value mismatch at argument %d in "
3894 "template parameter list for %qD",
3896 error (" expected a template of type %qD, got %qD",
3900 val = error_mark_node;
3909 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
3911 if (invalid_nontype_parm_type_p (t, complain))
3912 return error_mark_node;
3914 if (!uses_template_parms (arg) && !uses_template_parms (t))
3915 /* We used to call digest_init here. However, digest_init
3916 will report errors, which we don't want when complain
3917 is zero. More importantly, digest_init will try too
3918 hard to convert things: for example, `0' should not be
3919 converted to pointer type at this point according to
3920 the standard. Accepting this is not merely an
3921 extension, since deciding whether or not these
3922 conversions can occur is part of determining which
3923 function template to call, or whether a given explicit
3924 argument specification is valid. */
3925 val = convert_nontype_argument (t, arg);
3929 if (val == NULL_TREE)
3930 val = error_mark_node;
3931 else if (val == error_mark_node && (complain & tf_error))
3932 error ("could not convert template argument %qE to %qT", arg, t);
3938 /* Convert all template arguments to their appropriate types, and
3939 return a vector containing the innermost resulting template
3940 arguments. If any error occurs, return error_mark_node. Error and
3941 warning messages are issued under control of COMPLAIN.
3943 If REQUIRE_ALL_ARGUMENTS is nonzero, all arguments must be
3944 provided in ARGLIST, or else trailing parameters must have default
3945 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3946 deduction for any unspecified trailing arguments. */
3949 coerce_template_parms (tree parms,
3952 tsubst_flags_t complain,
3953 int require_all_arguments)
3955 int nparms, nargs, i, lost = 0;
3958 tree new_inner_args;
3960 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3961 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
3962 nparms = TREE_VEC_LENGTH (parms);
3966 && require_all_arguments
3967 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
3969 if (complain & tf_error)
3971 error ("wrong number of template arguments (%d, should be %d)",
3975 error ("provided for %q+D", in_decl);
3978 return error_mark_node;
3981 new_inner_args = make_tree_vec (nparms);
3982 new_args = add_outermost_template_args (args, new_inner_args);
3983 for (i = 0; i < nparms; i++)
3988 /* Get the Ith template parameter. */
3989 parm = TREE_VEC_ELT (parms, i);
3991 /* Calculate the Ith argument. */
3993 arg = TREE_VEC_ELT (inner_args, i);
3994 else if (require_all_arguments)
3995 /* There must be a default arg in this case. */
3996 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
4002 if (arg == error_mark_node)
4004 if (complain & tf_error)
4005 error ("template argument %d is invalid", i + 1);
4008 arg = convert_template_argument (TREE_VALUE (parm),
4009 arg, new_args, complain, i,
4012 if (arg == error_mark_node)
4014 TREE_VEC_ELT (new_inner_args, i) = arg;
4018 return error_mark_node;
4020 return new_inner_args;
4023 /* Returns 1 if template args OT and NT are equivalent. */
4026 template_args_equal (tree ot, tree nt)
4031 if (TREE_CODE (nt) == TREE_VEC)
4032 /* For member templates */
4033 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
4034 else if (TYPE_P (nt))
4035 return TYPE_P (ot) && same_type_p (ot, nt);
4036 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
4039 return cp_tree_equal (ot, nt);
4042 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
4043 of template arguments. Returns 0 otherwise. */
4046 comp_template_args (tree oldargs, tree newargs)
4050 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
4053 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
4055 tree nt = TREE_VEC_ELT (newargs, i);
4056 tree ot = TREE_VEC_ELT (oldargs, i);
4058 if (! template_args_equal (ot, nt))
4064 /* Given class template name and parameter list, produce a user-friendly name
4065 for the instantiation. */
4068 mangle_class_name_for_template (const char* name, tree parms, tree arglist)
4070 static struct obstack scratch_obstack;
4071 static char *scratch_firstobj;
4074 if (!scratch_firstobj)
4075 gcc_obstack_init (&scratch_obstack);
4077 obstack_free (&scratch_obstack, scratch_firstobj);
4078 scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
4080 #define ccat(C) obstack_1grow (&scratch_obstack, (C));
4081 #define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
4085 nparms = TREE_VEC_LENGTH (parms);
4086 arglist = INNERMOST_TEMPLATE_ARGS (arglist);
4087 gcc_assert (nparms == TREE_VEC_LENGTH (arglist));
4088 for (i = 0; i < nparms; i++)
4090 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4091 tree arg = TREE_VEC_ELT (arglist, i);
4096 if (TREE_CODE (parm) == TYPE_DECL)
4098 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4101 else if (TREE_CODE (parm) == TEMPLATE_DECL)
4103 if (TREE_CODE (arg) == TEMPLATE_DECL)
4105 /* Already substituted with real template. Just output
4106 the template name here */
4107 tree context = DECL_CONTEXT (arg);
4110 /* The template may be defined in a namespace, or
4111 may be a member template. */
4112 gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
4113 || CLASS_TYPE_P (context));
4114 cat (decl_as_string (DECL_CONTEXT (arg),
4115 TFF_PLAIN_IDENTIFIER));
4118 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
4121 /* Output the parameter declaration. */
4122 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4126 gcc_assert (TREE_CODE (parm) == PARM_DECL);
4128 /* No need to check arglist against parmlist here; we did that
4129 in coerce_template_parms, called from lookup_template_class. */
4130 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
4133 char *bufp = obstack_next_free (&scratch_obstack);
4135 while (bufp[offset - 1] == ' ')
4137 obstack_blank_fast (&scratch_obstack, offset);
4139 /* B<C<char> >, not B<C<char>> */
4140 if (bufp[offset - 1] == '>')
4145 return (char *) obstack_base (&scratch_obstack);
4149 classtype_mangled_name (tree t)
4151 if (CLASSTYPE_TEMPLATE_INFO (t)
4152 /* Specializations have already had their names set up in
4153 lookup_template_class. */
4154 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4156 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4158 /* For non-primary templates, the template parameters are
4159 implicit from their surrounding context. */
4160 if (PRIMARY_TEMPLATE_P (tmpl))
4162 tree name = DECL_NAME (tmpl);
4163 char *mangled_name = mangle_class_name_for_template
4164 (IDENTIFIER_POINTER (name),
4165 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4166 CLASSTYPE_TI_ARGS (t));
4167 tree id = get_identifier (mangled_name);
4168 IDENTIFIER_TEMPLATE (id) = name;
4173 return TYPE_IDENTIFIER (t);
4177 add_pending_template (tree d)
4179 tree ti = (TYPE_P (d)
4180 ? CLASSTYPE_TEMPLATE_INFO (d)
4181 : DECL_TEMPLATE_INFO (d));
4185 if (TI_PENDING_TEMPLATE_FLAG (ti))
4188 /* We are called both from instantiate_decl, where we've already had a
4189 tinst_level pushed, and instantiate_template, where we haven't.
4191 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4194 push_tinst_level (d);
4196 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4197 if (last_pending_template)
4198 TREE_CHAIN (last_pending_template) = pt;
4200 pending_templates = pt;
4202 last_pending_template = pt;
4204 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4211 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4212 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4213 documentation for TEMPLATE_ID_EXPR. */
4216 lookup_template_function (tree fns, tree arglist)
4220 if (fns == error_mark_node || arglist == error_mark_node)
4221 return error_mark_node;
4223 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
4224 gcc_assert (fns && (is_overloaded_fn (fns)
4225 || TREE_CODE (fns) == IDENTIFIER_NODE));
4227 if (BASELINK_P (fns))
4229 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
4231 BASELINK_FUNCTIONS (fns),
4236 type = TREE_TYPE (fns);
4237 if (TREE_CODE (fns) == OVERLOAD || !type)
4238 type = unknown_type_node;
4240 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
4243 /* Within the scope of a template class S<T>, the name S gets bound
4244 (in build_self_reference) to a TYPE_DECL for the class, not a
4245 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4246 or one of its enclosing classes, and that type is a template,
4247 return the associated TEMPLATE_DECL. Otherwise, the original
4248 DECL is returned. */
4251 maybe_get_template_decl_from_type_decl (tree decl)
4253 return (decl != NULL_TREE
4254 && TREE_CODE (decl) == TYPE_DECL
4255 && DECL_ARTIFICIAL (decl)
4256 && CLASS_TYPE_P (TREE_TYPE (decl))
4257 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4258 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4261 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4262 parameters, find the desired type.
4264 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4266 IN_DECL, if non-NULL, is the template declaration we are trying to
4269 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4270 the class we are looking up.
4272 Issue error and warning messages under control of COMPLAIN.
4274 If the template class is really a local class in a template
4275 function, then the FUNCTION_CONTEXT is the function in which it is
4278 ??? Note that this function is currently called *twice* for each
4279 template-id: the first time from the parser, while creating the
4280 incomplete type (finish_template_type), and the second type during the
4281 real instantiation (instantiate_template_class). This is surely something
4282 that we want to avoid. It also causes some problems with argument
4283 coercion (see convert_nontype_argument for more information on this). */
4286 lookup_template_class (tree d1,
4291 tsubst_flags_t complain)
4293 tree template = NULL_TREE, parmlist;
4296 timevar_push (TV_NAME_LOOKUP);
4298 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4300 tree value = innermost_non_namespace_value (d1);
4301 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
4306 push_decl_namespace (context);
4307 template = lookup_name (d1, /*prefer_type=*/0);
4308 template = maybe_get_template_decl_from_type_decl (template);
4310 pop_decl_namespace ();
4313 context = DECL_CONTEXT (template);
4315 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4317 tree type = TREE_TYPE (d1);
4319 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4320 an implicit typename for the second A. Deal with it. */
4321 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4322 type = TREE_TYPE (type);
4324 if (CLASSTYPE_TEMPLATE_INFO (type))
4326 template = CLASSTYPE_TI_TEMPLATE (type);
4327 d1 = DECL_NAME (template);
4330 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4331 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4333 template = TYPE_TI_TEMPLATE (d1);
4334 d1 = DECL_NAME (template);
4336 else if (TREE_CODE (d1) == TEMPLATE_DECL
4337 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4340 d1 = DECL_NAME (template);
4341 context = DECL_CONTEXT (template);
4344 /* Issue an error message if we didn't find a template. */
4347 if (complain & tf_error)
4348 error ("%qT is not a template", d1);
4349 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4352 if (TREE_CODE (template) != TEMPLATE_DECL
4353 /* Make sure it's a user visible template, if it was named by
4355 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4356 && !PRIMARY_TEMPLATE_P (template)))
4358 if (complain & tf_error)
4360 error ("non-template type %qT used as a template", d1);
4362 error ("for template declaration %q+D", in_decl);
4364 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4367 complain &= ~tf_user;
4369 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4371 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4372 template arguments */
4377 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4379 /* Consider an example where a template template parameter declared as
4381 template <class T, class U = std::allocator<T> > class TT
4383 The template parameter level of T and U are one level larger than
4384 of TT. To proper process the default argument of U, say when an
4385 instantiation `TT<int>' is seen, we need to build the full
4386 arguments containing {int} as the innermost level. Outer levels,
4387 available when not appearing as default template argument, can be
4388 obtained from `current_template_args ()'.
4390 Suppose that TT is later substituted with std::vector. The above
4391 instantiation is `TT<int, std::allocator<T> >' with TT at
4392 level 1, and T at level 2, while the template arguments at level 1
4393 becomes {std::vector} and the inner level 2 is {int}. */
4395 if (current_template_parms)
4396 arglist = add_to_template_args (current_template_args (), arglist);
4398 arglist2 = coerce_template_parms (parmlist, arglist, template,
4399 complain, /*require_all_args=*/1);
4400 if (arglist2 == error_mark_node
4401 || (!uses_template_parms (arglist2)
4402 && check_instantiated_args (template, arglist2, complain)))
4403 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4405 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4406 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4410 tree template_type = TREE_TYPE (template);
4413 tree found = NULL_TREE;
4416 int is_partial_instantiation;
4418 gen_tmpl = most_general_template (template);
4419 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4420 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4421 arg_depth = TMPL_ARGS_DEPTH (arglist);
4423 if (arg_depth == 1 && parm_depth > 1)
4425 /* We've been given an incomplete set of template arguments.
4428 template <class T> struct S1 {
4429 template <class U> struct S2 {};
4430 template <class U> struct S2<U*> {};
4433 we will be called with an ARGLIST of `U*', but the
4434 TEMPLATE will be `template <class T> template
4435 <class U> struct S1<T>::S2'. We must fill in the missing
4438 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4440 arg_depth = TMPL_ARGS_DEPTH (arglist);
4443 /* Now we should have enough arguments. */
4444 gcc_assert (parm_depth == arg_depth);
4446 /* From here on, we're only interested in the most general
4448 template = gen_tmpl;
4450 /* Calculate the BOUND_ARGS. These will be the args that are
4451 actually tsubst'd into the definition to create the
4455 /* We have multiple levels of arguments to coerce, at once. */
4457 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4459 tree bound_args = make_tree_vec (parm_depth);
4461 for (i = saved_depth,
4462 t = DECL_TEMPLATE_PARMS (template);
4463 i > 0 && t != NULL_TREE;
4464 --i, t = TREE_CHAIN (t))
4466 tree a = coerce_template_parms (TREE_VALUE (t),
4468 complain, /*require_all_args=*/1);
4470 /* Don't process further if one of the levels fails. */
4471 if (a == error_mark_node)
4473 /* Restore the ARGLIST to its full size. */
4474 TREE_VEC_LENGTH (arglist) = saved_depth;
4475 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4478 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4480 /* We temporarily reduce the length of the ARGLIST so
4481 that coerce_template_parms will see only the arguments
4482 corresponding to the template parameters it is
4484 TREE_VEC_LENGTH (arglist)--;
4487 /* Restore the ARGLIST to its full size. */
4488 TREE_VEC_LENGTH (arglist) = saved_depth;
4490 arglist = bound_args;
4494 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4495 INNERMOST_TEMPLATE_ARGS (arglist),
4497 complain, /*require_all_args=*/1);
4499 if (arglist == error_mark_node)
4500 /* We were unable to bind the arguments. */
4501 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4503 /* In the scope of a template class, explicit references to the
4504 template class refer to the type of the template, not any
4505 instantiation of it. For example, in:
4507 template <class T> class C { void f(C<T>); }
4509 the `C<T>' is just the same as `C'. Outside of the
4510 class, however, such a reference is an instantiation. */
4511 if (comp_template_args (TYPE_TI_ARGS (template_type),
4514 found = template_type;
4516 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4520 for (ctx = current_class_type;
4521 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4523 ? TYPE_CONTEXT (ctx)
4524 : DECL_CONTEXT (ctx)))
4525 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4528 /* We're not in the scope of the class, so the
4529 TEMPLATE_TYPE is not the type we want after all. */
4535 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4537 /* If we already have this specialization, return it. */
4538 found = retrieve_specialization (template, arglist,
4539 /*class_specializations_p=*/false);
4541 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4543 /* This type is a "partial instantiation" if any of the template
4544 arguments still involve template parameters. Note that we set
4545 IS_PARTIAL_INSTANTIATION for partial specializations as
4547 is_partial_instantiation = uses_template_parms (arglist);
4549 /* If the deduced arguments are invalid, then the binding
4551 if (!is_partial_instantiation
4552 && check_instantiated_args (template,
4553 INNERMOST_TEMPLATE_ARGS (arglist),
4555 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4557 if (!is_partial_instantiation
4558 && !PRIMARY_TEMPLATE_P (template)
4559 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4561 found = xref_tag_from_type (TREE_TYPE (template),
4562 DECL_NAME (template),
4563 /*tag_scope=*/ts_global);
4564 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4567 context = tsubst (DECL_CONTEXT (template), arglist,
4570 context = global_namespace;
4572 /* Create the type. */
4573 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4575 if (!is_partial_instantiation)
4577 set_current_access_from_decl (TYPE_NAME (template_type));
4578 t = start_enum (TYPE_IDENTIFIER (template_type));
4581 /* We don't want to call start_enum for this type, since
4582 the values for the enumeration constants may involve
4583 template parameters. And, no one should be interested
4584 in the enumeration constants for such a type. */
4585 t = make_node (ENUMERAL_TYPE);
4589 t = make_aggr_type (TREE_CODE (template_type));
4590 CLASSTYPE_DECLARED_CLASS (t)
4591 = CLASSTYPE_DECLARED_CLASS (template_type);
4592 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4593 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4595 /* A local class. Make sure the decl gets registered properly. */
4596 if (context == current_function_decl)
4597 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
4600 /* If we called start_enum or pushtag above, this information
4601 will already be set up. */
4604 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4606 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4607 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4608 TYPE_STUB_DECL (t) = type_decl;
4609 DECL_SOURCE_LOCATION (type_decl)
4610 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4613 type_decl = TYPE_NAME (t);
4615 TREE_PRIVATE (type_decl)
4616 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4617 TREE_PROTECTED (type_decl)
4618 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4619 DECL_IN_SYSTEM_HEADER (type_decl)
4620 = DECL_IN_SYSTEM_HEADER (template);
4621 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
4623 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
4624 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
4627 /* Set up the template information. We have to figure out which
4628 template is the immediate parent if this is a full
4630 if (parm_depth == 1 || is_partial_instantiation
4631 || !PRIMARY_TEMPLATE_P (template))
4632 /* This case is easy; there are no member templates involved. */
4636 /* This is a full instantiation of a member template. Look
4637 for a partial instantiation of which this is an instance. */
4639 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4640 found; found = TREE_CHAIN (found))
4643 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4645 /* We only want partial instantiations, here, not
4646 specializations or full instantiations. */
4647 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4648 || !uses_template_parms (TREE_VALUE (found)))
4651 /* Temporarily reduce by one the number of levels in the
4652 ARGLIST and in FOUND so as to avoid comparing the
4653 last set of arguments. */
4654 TREE_VEC_LENGTH (arglist)--;
4655 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4657 /* See if the arguments match. If they do, then TMPL is
4658 the partial instantiation we want. */
4659 success = comp_template_args (TREE_PURPOSE (found), arglist);
4661 /* Restore the argument vectors to their full size. */
4662 TREE_VEC_LENGTH (arglist)++;
4663 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4674 /* There was no partial instantiation. This happens
4675 where C<T> is a member template of A<T> and it's used
4678 template <typename T> struct B { A<T>::C<int> m; };
4681 Create the partial instantiation.
4683 TREE_VEC_LENGTH (arglist)--;
4684 found = tsubst (template, arglist, complain, NULL_TREE);
4685 TREE_VEC_LENGTH (arglist)++;
4689 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4690 DECL_TEMPLATE_INSTANTIATIONS (template)
4691 = tree_cons (arglist, t,
4692 DECL_TEMPLATE_INSTANTIATIONS (template));
4694 if (TREE_CODE (t) == ENUMERAL_TYPE
4695 && !is_partial_instantiation)
4696 /* Now that the type has been registered on the instantiations
4697 list, we set up the enumerators. Because the enumeration
4698 constants may involve the enumeration type itself, we make
4699 sure to register the type first, and then create the
4700 constants. That way, doing tsubst_expr for the enumeration
4701 constants won't result in recursive calls here; we'll find
4702 the instantiation and exit above. */
4703 tsubst_enum (template_type, t, arglist);
4705 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4707 if (TREE_CODE (t) != ENUMERAL_TYPE)
4708 DECL_NAME (type_decl) = classtype_mangled_name (t);
4709 if (is_partial_instantiation)
4710 /* If the type makes use of template parameters, the
4711 code that generates debugging information will crash. */
4712 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4714 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4716 timevar_pop (TV_NAME_LOOKUP);
4723 struct pointer_set_t *visited;
4726 /* Called from for_each_template_parm via walk_tree. */
4729 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
4732 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4733 tree_fn_t fn = pfd->fn;
4734 void *data = pfd->data;
4737 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4738 return error_mark_node;
4740 switch (TREE_CODE (t))
4743 if (TYPE_PTRMEMFUNC_P (t))
4749 if (!TYPE_TEMPLATE_INFO (t))
4751 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4752 fn, data, pfd->visited))
4753 return error_mark_node;
4757 /* Since we're not going to walk subtrees, we have to do this
4759 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4761 return error_mark_node;
4765 /* Check the return type. */
4766 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4767 return error_mark_node;
4769 /* Check the parameter types. Since default arguments are not
4770 instantiated until they are needed, the TYPE_ARG_TYPES may
4771 contain expressions that involve template parameters. But,
4772 no-one should be looking at them yet. And, once they're
4773 instantiated, they don't contain template parameters, so
4774 there's no point in looking at them then, either. */
4778 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4779 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
4781 return error_mark_node;
4783 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4784 want walk_tree walking into them itself. */
4790 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
4792 return error_mark_node;
4797 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
4798 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
4800 return error_mark_node;
4805 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
4806 && for_each_template_parm (DECL_INITIAL (t), fn, data,
4808 return error_mark_node;
4809 if (DECL_CONTEXT (t)
4810 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
4812 return error_mark_node;
4815 case BOUND_TEMPLATE_TEMPLATE_PARM:
4816 /* Record template parameters such as `T' inside `TT<T>'. */
4817 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
4818 return error_mark_node;
4821 case TEMPLATE_TEMPLATE_PARM:
4822 case TEMPLATE_TYPE_PARM:
4823 case TEMPLATE_PARM_INDEX:
4824 if (fn && (*fn)(t, data))
4825 return error_mark_node;
4827 return error_mark_node;
4831 /* A template template parameter is encountered. */
4832 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
4833 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4834 return error_mark_node;
4836 /* Already substituted template template parameter */
4842 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
4843 data, pfd->visited))
4844 return error_mark_node;
4848 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
4849 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4850 (TREE_TYPE (t)), fn, data,
4852 return error_mark_node;
4857 /* If there's no type, then this thing must be some expression
4858 involving template parameters. */
4859 if (!fn && !TREE_TYPE (t))
4860 return error_mark_node;
4865 case REINTERPRET_CAST_EXPR:
4866 case CONST_CAST_EXPR:
4867 case STATIC_CAST_EXPR:
4868 case DYNAMIC_CAST_EXPR:
4872 case PSEUDO_DTOR_EXPR:
4874 return error_mark_node;
4878 /* If we do not handle this case specially, we end up walking
4879 the BINFO hierarchy, which is circular, and therefore
4880 confuses walk_tree. */
4882 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
4884 return error_mark_node;
4891 /* We didn't find any template parameters we liked. */
4895 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
4896 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
4897 call FN with the parameter and the DATA.
4898 If FN returns nonzero, the iteration is terminated, and
4899 for_each_template_parm returns 1. Otherwise, the iteration
4900 continues. If FN never returns a nonzero value, the value
4901 returned by for_each_template_parm is 0. If FN is NULL, it is
4902 considered to be the function which always returns 1. */
4905 for_each_template_parm (tree t, tree_fn_t fn, void* data,
4906 struct pointer_set_t *visited)
4908 struct pair_fn_data pfd;
4915 /* Walk the tree. (Conceptually, we would like to walk without
4916 duplicates, but for_each_template_parm_r recursively calls
4917 for_each_template_parm, so we would need to reorganize a fair
4918 bit to use walk_tree_without_duplicates, so we keep our own
4921 pfd.visited = visited;
4923 pfd.visited = pointer_set_create ();
4924 result = walk_tree (&t,
4925 for_each_template_parm_r,
4927 pfd.visited) != NULL_TREE;
4932 pointer_set_destroy (pfd.visited);
4939 /* Returns true if T depends on any template parameter. */
4942 uses_template_parms (tree t)
4945 int saved_processing_template_decl;
4947 saved_processing_template_decl = processing_template_decl;
4948 if (!saved_processing_template_decl)
4949 processing_template_decl = 1;
4951 dependent_p = dependent_type_p (t);
4952 else if (TREE_CODE (t) == TREE_VEC)
4953 dependent_p = any_dependent_template_arguments_p (t);
4954 else if (TREE_CODE (t) == TREE_LIST)
4955 dependent_p = (uses_template_parms (TREE_VALUE (t))
4956 || uses_template_parms (TREE_CHAIN (t)));
4959 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
4960 || TREE_CODE (t) == OVERLOAD
4961 || TREE_CODE (t) == BASELINK
4962 || TREE_CODE (t) == IDENTIFIER_NODE
4963 || CONSTANT_CLASS_P (t))
4964 dependent_p = (type_dependent_expression_p (t)
4965 || value_dependent_expression_p (t));
4968 gcc_assert (t == error_mark_node);
4969 dependent_p = false;
4972 processing_template_decl = saved_processing_template_decl;
4977 /* Returns true if T depends on any template parameter with level LEVEL. */
4980 uses_template_parms_level (tree t, int level)
4982 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
4985 static int tinst_depth;
4986 extern int max_tinst_depth;
4987 #ifdef GATHER_STATISTICS
4990 static int tinst_level_tick;
4991 static int last_template_error_tick;
4993 /* We're starting to instantiate D; record the template instantiation context
4994 for diagnostics and to restore it later. */
4997 push_tinst_level (tree d)
5001 if (tinst_depth >= max_tinst_depth)
5003 /* If the instantiation in question still has unbound template parms,
5004 we don't really care if we can't instantiate it, so just return.
5005 This happens with base instantiation for implicit `typename'. */
5006 if (uses_template_parms (d))
5009 last_template_error_tick = tinst_level_tick;
5010 error ("template instantiation depth exceeds maximum of %d (use "
5011 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
5012 max_tinst_depth, d);
5014 print_instantiation_context ();
5019 new = make_node (TINST_LEVEL);
5020 TINST_DECL (new) = d;
5021 TINST_LOCATION (new) = input_location;
5022 TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
5023 TREE_CHAIN (new) = current_tinst_level;
5024 current_tinst_level = new;
5027 #ifdef GATHER_STATISTICS
5028 if (tinst_depth > depth_reached)
5029 depth_reached = tinst_depth;
5036 /* We're done instantiating this template; return to the instantiation
5040 pop_tinst_level (void)
5042 tree old = current_tinst_level;
5044 /* Restore the filename and line number stashed away when we started
5045 this instantiation. */
5046 input_location = TINST_LOCATION (old);
5047 in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
5048 current_tinst_level = TREE_CHAIN (old);
5053 /* We're instantiating a deferred template; restore the template
5054 instantiation context in which the instantiation was requested, which
5055 is one step out from LEVEL. */
5058 reopen_tinst_level (tree level)
5063 for (t = level; t; t = TREE_CHAIN (t))
5066 current_tinst_level = level;
5070 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
5071 vector of template arguments, as for tsubst.
5073 Returns an appropriate tsubst'd friend declaration. */
5076 tsubst_friend_function (tree decl, tree args)
5080 if (TREE_CODE (decl) == FUNCTION_DECL
5081 && DECL_TEMPLATE_INSTANTIATION (decl)
5082 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
5083 /* This was a friend declared with an explicit template
5084 argument list, e.g.:
5088 to indicate that f was a template instantiation, not a new
5089 function declaration. Now, we have to figure out what
5090 instantiation of what template. */
5092 tree template_id, arglist, fns;
5095 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
5097 /* Friend functions are looked up in the containing namespace scope.
5098 We must enter that scope, to avoid finding member functions of the
5099 current cless with same name. */
5100 push_nested_namespace (ns);
5101 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
5102 tf_error | tf_warning, NULL_TREE);
5103 pop_nested_namespace (ns);
5104 arglist = tsubst (DECL_TI_ARGS (decl), args,
5105 tf_error | tf_warning, NULL_TREE);
5106 template_id = lookup_template_function (fns, arglist);
5108 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
5109 tmpl = determine_specialization (template_id, new_friend,
5111 /*need_member_template=*/0,
5112 TREE_VEC_LENGTH (args));
5113 return instantiate_template (tmpl, new_args, tf_error);
5116 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
5118 /* The NEW_FRIEND will look like an instantiation, to the
5119 compiler, but is not an instantiation from the point of view of
5120 the language. For example, we might have had:
5122 template <class T> struct S {
5123 template <class U> friend void f(T, U);
5126 Then, in S<int>, template <class U> void f(int, U) is not an
5127 instantiation of anything. */
5128 if (new_friend == error_mark_node)
5129 return error_mark_node;
5131 DECL_USE_TEMPLATE (new_friend) = 0;
5132 if (TREE_CODE (decl) == TEMPLATE_DECL)
5134 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
5135 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
5136 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5139 /* The mangled name for the NEW_FRIEND is incorrect. The function
5140 is not a template instantiation and should not be mangled like
5141 one. Therefore, we forget the mangling here; we'll recompute it
5142 later if we need it. */
5143 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5145 SET_DECL_RTL (new_friend, NULL_RTX);
5146 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5149 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5152 tree new_friend_template_info;
5153 tree new_friend_result_template_info;
5155 int new_friend_is_defn;
5157 /* We must save some information from NEW_FRIEND before calling
5158 duplicate decls since that function will free NEW_FRIEND if
5160 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5161 new_friend_is_defn =
5162 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5163 (template_for_substitution (new_friend)))
5165 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5167 /* This declaration is a `primary' template. */
5168 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5170 new_friend_result_template_info
5171 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5174 new_friend_result_template_info = NULL_TREE;
5176 /* Inside pushdecl_namespace_level, we will push into the
5177 current namespace. However, the friend function should go
5178 into the namespace of the template. */
5179 ns = decl_namespace_context (new_friend);
5180 push_nested_namespace (ns);
5181 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
5182 pop_nested_namespace (ns);
5184 if (old_decl != new_friend)
5186 /* This new friend declaration matched an existing
5187 declaration. For example, given:
5189 template <class T> void f(T);
5190 template <class U> class C {
5191 template <class T> friend void f(T) {}
5194 the friend declaration actually provides the definition
5195 of `f', once C has been instantiated for some type. So,
5196 old_decl will be the out-of-class template declaration,
5197 while new_friend is the in-class definition.
5199 But, if `f' was called before this point, the
5200 instantiation of `f' will have DECL_TI_ARGS corresponding
5201 to `T' but not to `U', references to which might appear
5202 in the definition of `f'. Previously, the most general
5203 template for an instantiation of `f' was the out-of-class
5204 version; now it is the in-class version. Therefore, we
5205 run through all specialization of `f', adding to their
5206 DECL_TI_ARGS appropriately. In particular, they need a
5207 new set of outer arguments, corresponding to the
5208 arguments for this class instantiation.
5210 The same situation can arise with something like this:
5213 template <class T> class C {
5217 when `C<int>' is instantiated. Now, `f(int)' is defined
5220 if (!new_friend_is_defn)
5221 /* On the other hand, if the in-class declaration does
5222 *not* provide a definition, then we don't want to alter
5223 existing definitions. We can just leave everything
5228 /* Overwrite whatever template info was there before, if
5229 any, with the new template information pertaining to
5231 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5233 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5234 reregister_specialization (new_friend,
5235 most_general_template (old_decl),
5240 tree new_friend_args;
5242 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5243 = new_friend_result_template_info;
5245 new_friend_args = TI_ARGS (new_friend_template_info);
5246 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5250 tree spec = TREE_VALUE (t);
5253 = add_outermost_template_args (new_friend_args,
5254 DECL_TI_ARGS (spec));
5257 /* Now, since specializations are always supposed to
5258 hang off of the most general template, we must move
5260 t = most_general_template (old_decl);
5263 DECL_TEMPLATE_SPECIALIZATIONS (t)
5264 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5265 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5266 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5271 /* The information from NEW_FRIEND has been merged into OLD_DECL
5272 by duplicate_decls. */
5273 new_friend = old_decl;
5278 tree context = DECL_CONTEXT (new_friend);
5282 template <class T> class C {
5283 template <class U> friend void C1<U>::f (); // case 1
5284 friend void C2<T>::f (); // case 2
5286 we only need to make sure CONTEXT is a complete type for
5287 case 2. To distinguish between the two cases, we note that
5288 CONTEXT of case 1 remains dependent type after tsubst while
5289 this isn't true for case 2. */
5290 ++processing_template_decl;
5291 dependent_p = dependent_type_p (context);
5292 --processing_template_decl;
5295 && !complete_type_or_else (context, NULL_TREE))
5296 return error_mark_node;
5298 if (COMPLETE_TYPE_P (context))
5300 /* Check to see that the declaration is really present, and,
5301 possibly obtain an improved declaration. */
5302 tree fn = check_classfn (context,
5303 new_friend, NULL_TREE);
5313 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5314 template arguments, as for tsubst.
5316 Returns an appropriate tsubst'd friend type or error_mark_node on
5320 tsubst_friend_class (tree friend_tmpl, tree args)
5326 context = DECL_CONTEXT (friend_tmpl);
5330 if (TREE_CODE (context) == NAMESPACE_DECL)
5331 push_nested_namespace (context);
5333 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5336 /* First, we look for a class template. */
5337 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0);
5339 /* But, if we don't find one, it might be because we're in a
5340 situation like this:
5348 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5349 for `S<int>', not the TEMPLATE_DECL. */
5350 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5352 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1);
5353 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5356 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5358 /* The friend template has already been declared. Just
5359 check to see that the declarations match, and install any new
5360 default parameters. We must tsubst the default parameters,
5361 of course. We only need the innermost template parameters
5362 because that is all that redeclare_class_template will look
5364 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5365 > TMPL_ARGS_DEPTH (args))
5368 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5369 args, tf_error | tf_warning);
5370 redeclare_class_template (TREE_TYPE (tmpl), parms);
5373 friend_type = TREE_TYPE (tmpl);
5377 /* The friend template has not already been declared. In this
5378 case, the instantiation of the template class will cause the
5379 injection of this template into the global scope. */
5380 tmpl = tsubst (friend_tmpl, args, tf_error | tf_warning, NULL_TREE);
5382 /* The new TMPL is not an instantiation of anything, so we
5383 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5384 the new type because that is supposed to be the corresponding
5385 template decl, i.e., TMPL. */
5386 DECL_USE_TEMPLATE (tmpl) = 0;
5387 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5388 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5389 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5390 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5392 /* Inject this template into the global scope. */
5393 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
5398 if (TREE_CODE (context) == NAMESPACE_DECL)
5399 pop_nested_namespace (context);
5401 pop_nested_class ();
5407 /* Returns zero if TYPE cannot be completed later due to circularity.
5408 Otherwise returns one. */
5411 can_complete_type_without_circularity (tree type)
5413 if (type == NULL_TREE || type == error_mark_node)
5415 else if (COMPLETE_TYPE_P (type))
5417 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5418 return can_complete_type_without_circularity (TREE_TYPE (type));
5419 else if (CLASS_TYPE_P (type)
5420 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5427 instantiate_class_template (tree type)
5429 tree template, args, pattern, t, member;
5434 if (type == error_mark_node)
5435 return error_mark_node;
5437 if (TYPE_BEING_DEFINED (type)
5438 || COMPLETE_TYPE_P (type)
5439 || dependent_type_p (type))
5442 /* Figure out which template is being instantiated. */
5443 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5444 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
5446 /* Figure out which arguments are being used to do the
5448 args = CLASSTYPE_TI_ARGS (type);
5450 /* Determine what specialization of the original template to
5452 t = most_specialized_class (template, args);
5453 if (t == error_mark_node)
5455 const char *str = "candidates are:";
5456 error ("ambiguous class template instantiation for %q#T", type);
5457 for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t;
5460 if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args))
5462 error ("%s %+#T", str, TREE_TYPE (t));
5466 TYPE_BEING_DEFINED (type) = 1;
5467 return error_mark_node;
5471 pattern = TREE_TYPE (t);
5473 pattern = TREE_TYPE (template);
5475 /* If the template we're instantiating is incomplete, then clearly
5476 there's nothing we can do. */
5477 if (!COMPLETE_TYPE_P (pattern))
5480 /* If we've recursively instantiated too many templates, stop. */
5481 if (! push_tinst_level (type))
5484 /* Now we're really doing the instantiation. Mark the type as in
5485 the process of being defined. */
5486 TYPE_BEING_DEFINED (type) = 1;
5488 /* We may be in the middle of deferred access check. Disable
5490 push_deferring_access_checks (dk_no_deferred);
5492 push_to_top_level ();
5496 /* This TYPE is actually an instantiation of a partial
5497 specialization. We replace the innermost set of ARGS with
5498 the arguments appropriate for substitution. For example,
5501 template <class T> struct S {};
5502 template <class T> struct S<T*> {};
5504 and supposing that we are instantiating S<int*>, ARGS will
5505 present be {int*} but we need {int}. */
5507 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t),
5510 /* If there were multiple levels in ARGS, replacing the
5511 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
5512 want, so we make a copy first. */
5513 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
5515 args = copy_node (args);
5516 SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args);
5522 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5524 /* Set the input location to the template definition. This is needed
5525 if tsubsting causes an error. */
5526 typedecl = TYPE_MAIN_DECL (type);
5527 input_location = DECL_SOURCE_LOCATION (typedecl);
5528 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
5530 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5531 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5532 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5533 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5534 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5535 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5536 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5537 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5538 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5539 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5540 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5541 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5542 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5543 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5544 if (ANON_AGGR_TYPE_P (pattern))
5545 SET_ANON_AGGR_TYPE_P (type);
5546 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
5548 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
5549 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
5552 pbinfo = TYPE_BINFO (pattern);
5554 /* We should never instantiate a nested class before its enclosing
5555 class; we need to look up the nested class by name before we can
5556 instantiate it, and that lookup should instantiate the enclosing
5558 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5559 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5560 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
5562 base_list = NULL_TREE;
5563 if (BINFO_N_BASE_BINFOS (pbinfo))
5566 tree context = TYPE_CONTEXT (type);
5570 /* We must enter the scope containing the type, as that is where
5571 the accessibility of types named in dependent bases are
5573 pushed_scope = push_scope (context ? context : global_namespace);
5575 /* Substitute into each of the bases to determine the actual
5577 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
5580 tree access = BINFO_BASE_ACCESS (pbinfo, i);
5582 /* Substitute to figure out the base class. */
5583 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
5584 if (base == error_mark_node)
5587 base_list = tree_cons (access, base, base_list);
5588 if (BINFO_VIRTUAL_P (pbase_binfo))
5589 TREE_TYPE (base_list) = integer_type_node;
5592 /* The list is now in reverse order; correct that. */
5593 base_list = nreverse (base_list);
5596 pop_scope (pushed_scope);
5598 /* Now call xref_basetypes to set up all the base-class
5600 xref_basetypes (type, base_list);
5603 /* Now that our base classes are set up, enter the scope of the
5604 class, so that name lookups into base classes, etc. will work
5605 correctly. This is precisely analogous to what we do in
5606 begin_class_definition when defining an ordinary non-template
5610 /* Now members are processed in the order of declaration. */
5611 for (member = CLASSTYPE_DECL_LIST (pattern);
5612 member; member = TREE_CHAIN (member))
5614 tree t = TREE_VALUE (member);
5616 if (TREE_PURPOSE (member))
5620 /* Build new CLASSTYPE_NESTED_UTDS. */
5623 tree name = TYPE_IDENTIFIER (tag);
5625 bool class_template_p;
5627 class_template_p = (TREE_CODE (tag) != ENUMERAL_TYPE
5628 && TYPE_LANG_SPECIFIC (tag)
5629 && CLASSTYPE_IS_TEMPLATE (tag));
5630 /* If the member is a class template, then -- even after
5631 substitution -- there may be dependent types in the
5632 template argument list for the class. We increment
5633 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5634 that function will assume that no types are dependent
5635 when outside of a template. */
5636 if (class_template_p)
5637 ++processing_template_decl;
5638 newtag = tsubst (tag, args, tf_error, NULL_TREE);
5639 if (class_template_p)
5640 --processing_template_decl;
5641 if (newtag == error_mark_node)
5644 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5646 if (class_template_p)
5647 /* Unfortunately, lookup_template_class sets
5648 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5649 instantiation (i.e., for the type of a member
5650 template class nested within a template class.)
5651 This behavior is required for
5652 maybe_process_partial_specialization to work
5653 correctly, but is not accurate in this case;
5654 the TAG is not an instantiation of anything.
5655 (The corresponding TEMPLATE_DECL is an
5656 instantiation, but the TYPE is not.) */
5657 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5659 /* Now, we call pushtag to put this NEWTAG into the scope of
5660 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5661 pushtag calling push_template_decl. We don't have to do
5662 this for enums because it will already have been done in
5665 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5666 pushtag (name, newtag, /*tag_scope=*/ts_current);
5669 else if (TREE_CODE (t) == FUNCTION_DECL
5670 || DECL_FUNCTION_TEMPLATE_P (t))
5672 /* Build new TYPE_METHODS. */
5675 if (TREE_CODE (t) == TEMPLATE_DECL)
5676 ++processing_template_decl;
5677 r = tsubst (t, args, tf_error, NULL_TREE);
5678 if (TREE_CODE (t) == TEMPLATE_DECL)
5679 --processing_template_decl;
5680 set_current_access_from_decl (r);
5681 grok_special_member_properties (r);
5682 finish_member_declaration (r);
5686 /* Build new TYPE_FIELDS. */
5688 if (TREE_CODE (t) != CONST_DECL)
5692 /* The the file and line for this declaration, to
5693 assist in error message reporting. Since we
5694 called push_tinst_level above, we don't need to
5696 input_location = DECL_SOURCE_LOCATION (t);
5698 if (TREE_CODE (t) == TEMPLATE_DECL)
5699 ++processing_template_decl;
5700 r = tsubst (t, args, tf_error | tf_warning, NULL_TREE);
5701 if (TREE_CODE (t) == TEMPLATE_DECL)
5702 --processing_template_decl;
5703 if (TREE_CODE (r) == VAR_DECL)
5707 [t]he initialization (and any associated
5708 side-effects) of a static data member does
5709 not occur unless the static data member is
5710 itself used in a way that requires the
5711 definition of the static data member to
5714 Therefore, we do not substitute into the
5715 initialized for the static data member here. */
5716 finish_static_data_member_decl
5719 /*asmspec_tree=*/NULL_TREE,
5721 if (DECL_INITIALIZED_IN_CLASS_P (r))
5722 check_static_variable_definition (r, TREE_TYPE (r));
5724 else if (TREE_CODE (r) == FIELD_DECL)
5726 /* Determine whether R has a valid type and can be
5727 completed later. If R is invalid, then it is
5728 replaced by error_mark_node so that it will not be
5729 added to TYPE_FIELDS. */
5730 tree rtype = TREE_TYPE (r);
5731 if (can_complete_type_without_circularity (rtype))
5732 complete_type (rtype);
5734 if (!COMPLETE_TYPE_P (rtype))
5736 cxx_incomplete_type_error (r, rtype);
5737 r = error_mark_node;
5741 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5742 such a thing will already have been added to the field
5743 list by tsubst_enum in finish_member_declaration in the
5744 CLASSTYPE_NESTED_UTDS case above. */
5745 if (!(TREE_CODE (r) == TYPE_DECL
5746 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5747 && DECL_ARTIFICIAL (r)))
5749 set_current_access_from_decl (r);
5750 finish_member_declaration (r);
5757 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5759 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5761 tree friend_type = t;
5762 bool adjust_processing_template_decl = false;
5764 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5766 /* template <class T> friend class C; */
5767 friend_type = tsubst_friend_class (friend_type, args);
5768 adjust_processing_template_decl = true;
5770 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
5772 /* template <class T> friend class C::D; */
5773 friend_type = tsubst (friend_type, args,
5774 tf_error | tf_warning, NULL_TREE);
5775 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5776 friend_type = TREE_TYPE (friend_type);
5777 adjust_processing_template_decl = true;
5779 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
5781 /* This could be either
5785 when dependent_type_p is false or
5787 template <class U> friend class T::C;
5790 friend_type = tsubst (friend_type, args,
5791 tf_error | tf_warning, NULL_TREE);
5792 /* Bump processing_template_decl for correct
5793 dependent_type_p calculation. */
5794 ++processing_template_decl;
5795 if (dependent_type_p (friend_type))
5796 adjust_processing_template_decl = true;
5797 --processing_template_decl;
5799 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
5800 && hidden_name_p (TYPE_NAME (friend_type)))
5804 where C hasn't been declared yet. Let's lookup name
5805 from namespace scope directly, bypassing any name that
5806 come from dependent base class. */
5807 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
5809 /* The call to xref_tag_from_type does injection for friend
5811 push_nested_namespace (ns);
5813 xref_tag_from_type (friend_type, NULL_TREE,
5814 /*tag_scope=*/ts_current);
5815 pop_nested_namespace (ns);
5817 else if (uses_template_parms (friend_type))
5818 /* friend class C<T>; */
5819 friend_type = tsubst (friend_type, args,
5820 tf_error | tf_warning, NULL_TREE);
5825 where C is already declared or
5827 friend class C<int>;
5829 We don't have to do anything in these cases. */
5831 if (adjust_processing_template_decl)
5832 /* Trick make_friend_class into realizing that the friend
5833 we're adding is a template, not an ordinary class. It's
5834 important that we use make_friend_class since it will
5835 perform some error-checking and output cross-reference
5837 ++processing_template_decl;
5839 if (friend_type != error_mark_node)
5840 make_friend_class (type, friend_type, /*complain=*/false);
5842 if (adjust_processing_template_decl)
5843 --processing_template_decl;
5847 /* Build new DECL_FRIENDLIST. */
5850 /* The the file and line for this declaration, to
5851 assist in error message reporting. Since we
5852 called push_tinst_level above, we don't need to
5854 input_location = DECL_SOURCE_LOCATION (t);
5856 if (TREE_CODE (t) == TEMPLATE_DECL)
5858 ++processing_template_decl;
5859 push_deferring_access_checks (dk_no_check);
5862 r = tsubst_friend_function (t, args);
5863 add_friend (type, r, /*complain=*/false);
5864 if (TREE_CODE (t) == TEMPLATE_DECL)
5866 pop_deferring_access_checks ();
5867 --processing_template_decl;
5873 /* Set the file and line number information to whatever is given for
5874 the class itself. This puts error messages involving generated
5875 implicit functions at a predictable point, and the same point
5876 that would be used for non-template classes. */
5877 input_location = DECL_SOURCE_LOCATION (typedecl);
5879 unreverse_member_declarations (type);
5880 finish_struct_1 (type);
5881 TYPE_BEING_DEFINED (type) = 0;
5883 /* Now that the class is complete, instantiate default arguments for
5884 any member functions. We don't do this earlier because the
5885 default arguments may reference members of the class. */
5886 if (!PRIMARY_TEMPLATE_P (template))
5887 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
5888 if (TREE_CODE (t) == FUNCTION_DECL
5889 /* Implicitly generated member functions will not have template
5890 information; they are not instantiations, but instead are
5891 created "fresh" for each instantiation. */
5892 && DECL_TEMPLATE_INFO (t))
5893 tsubst_default_arguments (t);
5896 pop_from_top_level ();
5897 pop_deferring_access_checks ();
5900 /* The vtable for a template class can be emitted in any translation
5901 unit in which the class is instantiated. When there is no key
5902 method, however, finish_struct_1 will already have added TYPE to
5903 the keyed_classes list. */
5904 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
5905 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
5911 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
5917 else if (TYPE_P (t))
5918 r = tsubst (t, args, complain, in_decl);
5921 r = tsubst_expr (t, args, complain, in_decl);
5923 if (!uses_template_parms (r))
5925 /* Sometimes, one of the args was an expression involving a
5926 template constant parameter, like N - 1. Now that we've
5927 tsubst'd, we might have something like 2 - 1. This will
5928 confuse lookup_template_class, so we do constant folding
5929 here. We have to unset processing_template_decl, to fool
5930 tsubst_copy_and_build() into building an actual tree. */
5932 /* If the TREE_TYPE of ARG is not NULL_TREE, ARG is already
5933 as simple as it's going to get, and trying to reprocess
5934 the trees will break. Once tsubst_expr et al DTRT for
5935 non-dependent exprs, this code can go away, as the type
5936 will always be set. */
5939 int saved_processing_template_decl = processing_template_decl;
5940 processing_template_decl = 0;
5941 r = tsubst_copy_and_build (r, /*args=*/NULL_TREE,
5942 tf_error, /*in_decl=*/NULL_TREE,
5943 /*function_p=*/false);
5944 processing_template_decl = saved_processing_template_decl;
5952 /* Substitute ARGS into the vector or list of template arguments T. */
5955 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
5957 int len = TREE_VEC_LENGTH (t);
5958 int need_new = 0, i;
5959 tree *elts = alloca (len * sizeof (tree));
5961 for (i = 0; i < len; i++)
5963 tree orig_arg = TREE_VEC_ELT (t, i);
5966 if (TREE_CODE (orig_arg) == TREE_VEC)
5967 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
5969 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
5971 if (new_arg == error_mark_node)
5972 return error_mark_node;
5975 if (new_arg != orig_arg)
5982 t = make_tree_vec (len);
5983 for (i = 0; i < len; i++)
5984 TREE_VEC_ELT (t, i) = elts[i];
5989 /* Return the result of substituting ARGS into the template parameters
5990 given by PARMS. If there are m levels of ARGS and m + n levels of
5991 PARMS, then the result will contain n levels of PARMS. For
5992 example, if PARMS is `template <class T> template <class U>
5993 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5994 result will be `template <int*, double, class V>'. */
5997 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
6002 for (new_parms = &r;
6003 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
6004 new_parms = &(TREE_CHAIN (*new_parms)),
6005 parms = TREE_CHAIN (parms))
6008 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
6011 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
6013 tree tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
6014 tree default_value = TREE_PURPOSE (tuple);
6015 tree parm_decl = TREE_VALUE (tuple);
6017 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
6018 if (TREE_CODE (parm_decl) == PARM_DECL
6019 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
6020 parm_decl = error_mark_node;
6021 default_value = tsubst_template_arg (default_value, args,
6022 complain, NULL_TREE);
6024 tuple = build_tree_list (default_value, parm_decl);
6025 TREE_VEC_ELT (new_vec, i) = tuple;
6029 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
6030 - TMPL_ARGS_DEPTH (args)),
6031 new_vec, NULL_TREE);
6037 /* Substitute the ARGS into the indicated aggregate (or enumeration)
6038 type T. If T is not an aggregate or enumeration type, it is
6039 handled as if by tsubst. IN_DECL is as for tsubst. If
6040 ENTERING_SCOPE is nonzero, T is the context for a template which
6041 we are presently tsubst'ing. Return the substituted value. */
6044 tsubst_aggr_type (tree t,
6046 tsubst_flags_t complain,
6053 switch (TREE_CODE (t))
6056 if (TYPE_PTRMEMFUNC_P (t))
6057 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
6059 /* Else fall through. */
6062 if (TYPE_TEMPLATE_INFO (t))
6068 /* First, determine the context for the type we are looking
6070 context = TYPE_CONTEXT (t);
6072 context = tsubst_aggr_type (context, args, complain,
6073 in_decl, /*entering_scope=*/1);
6075 /* Then, figure out what arguments are appropriate for the
6076 type we are trying to find. For example, given:
6078 template <class T> struct S;
6079 template <class T, class U> void f(T, U) { S<U> su; }
6081 and supposing that we are instantiating f<int, double>,
6082 then our ARGS will be {int, double}, but, when looking up
6083 S we only want {double}. */
6084 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
6086 if (argvec == error_mark_node)
6087 return error_mark_node;
6089 r = lookup_template_class (t, argvec, in_decl, context,
6090 entering_scope, complain);
6092 return cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6095 /* This is not a template type, so there's nothing to do. */
6099 return tsubst (t, args, complain, in_decl);
6103 /* Substitute into the default argument ARG (a default argument for
6104 FN), which has the indicated TYPE. */
6107 tsubst_default_argument (tree fn, tree type, tree arg)
6109 tree saved_class_ptr = NULL_TREE;
6110 tree saved_class_ref = NULL_TREE;
6112 /* This default argument came from a template. Instantiate the
6113 default argument here, not in tsubst. In the case of
6122 we must be careful to do name lookup in the scope of S<T>,
6123 rather than in the current class. */
6124 push_access_scope (fn);
6125 /* The default argument expression should not be considered to be
6126 within the scope of FN. Since push_access_scope sets
6127 current_function_decl, we must explicitly clear it here. */
6128 current_function_decl = NULL_TREE;
6129 /* The "this" pointer is not valid in a default argument. */
6132 saved_class_ptr = current_class_ptr;
6133 cp_function_chain->x_current_class_ptr = NULL_TREE;
6134 saved_class_ref = current_class_ref;
6135 cp_function_chain->x_current_class_ref = NULL_TREE;
6138 push_deferring_access_checks(dk_no_deferred);
6139 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
6140 tf_error | tf_warning, NULL_TREE);
6141 pop_deferring_access_checks();
6143 /* Restore the "this" pointer. */
6146 cp_function_chain->x_current_class_ptr = saved_class_ptr;
6147 cp_function_chain->x_current_class_ref = saved_class_ref;
6150 pop_access_scope (fn);
6152 /* Make sure the default argument is reasonable. */
6153 arg = check_default_argument (type, arg);
6158 /* Substitute into all the default arguments for FN. */
6161 tsubst_default_arguments (tree fn)
6166 tmpl_args = DECL_TI_ARGS (fn);
6168 /* If this function is not yet instantiated, we certainly don't need
6169 its default arguments. */
6170 if (uses_template_parms (tmpl_args))
6173 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
6175 arg = TREE_CHAIN (arg))
6176 if (TREE_PURPOSE (arg))
6177 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
6179 TREE_PURPOSE (arg));
6182 /* Substitute the ARGS into the T, which is a _DECL. Return the
6183 result of the substitution. Issue error and warning messages under
6184 control of COMPLAIN. */
6187 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
6189 location_t saved_loc;
6193 /* Set the filename and linenumber to improve error-reporting. */
6194 saved_loc = input_location;
6195 input_location = DECL_SOURCE_LOCATION (t);
6197 switch (TREE_CODE (t))
6201 /* We can get here when processing a member function template,
6202 member class template, and template template parameter of
6203 a template class. */
6204 tree decl = DECL_TEMPLATE_RESULT (t);
6209 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
6211 /* Template template parameter is treated here. */
6212 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6213 if (new_type == error_mark_node)
6214 return error_mark_node;
6217 TREE_CHAIN (r) = NULL_TREE;
6218 TREE_TYPE (r) = new_type;
6219 DECL_TEMPLATE_RESULT (r)
6220 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
6221 DECL_TEMPLATE_PARMS (r)
6222 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6224 TYPE_NAME (new_type) = r;
6228 /* We might already have an instance of this template.
6229 The ARGS are for the surrounding class type, so the
6230 full args contain the tsubst'd args for the context,
6231 plus the innermost args from the template decl. */
6232 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
6233 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
6234 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
6235 full_args = tsubst_template_args (tmpl_args, args,
6237 if (full_args == error_mark_node)
6238 return error_mark_node;
6240 /* tsubst_template_args doesn't copy the vector if
6241 nothing changed. But, *something* should have
6243 gcc_assert (full_args != tmpl_args);
6245 spec = retrieve_specialization (t, full_args,
6246 /*class_specializations_p=*/true);
6247 if (spec != NULL_TREE)
6253 /* Make a new template decl. It will be similar to the
6254 original, but will record the current template arguments.
6255 We also create a new function declaration, which is just
6256 like the old one, but points to this new template, rather
6257 than the old one. */
6259 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
6260 TREE_CHAIN (r) = NULL_TREE;
6263 = tsubst_aggr_type (DECL_CONTEXT (t), args,
6265 /*entering_scope=*/1);
6266 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6268 if (TREE_CODE (decl) == TYPE_DECL)
6270 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6271 if (new_type == error_mark_node)
6272 return error_mark_node;
6274 TREE_TYPE (r) = new_type;
6275 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6276 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6277 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6281 tree new_decl = tsubst (decl, args, complain, in_decl);
6282 if (new_decl == error_mark_node)
6283 return error_mark_node;
6285 DECL_TEMPLATE_RESULT (r) = new_decl;
6286 DECL_TI_TEMPLATE (new_decl) = r;
6287 TREE_TYPE (r) = TREE_TYPE (new_decl);
6288 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6291 SET_DECL_IMPLICIT_INSTANTIATION (r);
6292 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6293 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6295 /* The template parameters for this new template are all the
6296 template parameters for the old template, except the
6297 outermost level of parameters. */
6298 DECL_TEMPLATE_PARMS (r)
6299 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6302 if (PRIMARY_TEMPLATE_P (t))
6303 DECL_PRIMARY_TEMPLATE (r) = r;
6305 if (TREE_CODE (decl) != TYPE_DECL)
6306 /* Record this non-type partial instantiation. */
6307 register_specialization (r, t,
6308 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
6316 tree argvec = NULL_TREE;
6324 /* Nobody should be tsubst'ing into non-template functions. */
6325 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
6327 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6332 /* If T is not dependent, just return it. We have to
6333 increment PROCESSING_TEMPLATE_DECL because
6334 value_dependent_expression_p assumes that nothing is
6335 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6336 ++processing_template_decl;
6337 dependent_p = value_dependent_expression_p (t);
6338 --processing_template_decl;
6342 /* Calculate the most general template of which R is a
6343 specialization, and the complete set of arguments used to
6345 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6346 argvec = tsubst_template_args (DECL_TI_ARGS
6347 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6348 args, complain, in_decl);
6350 /* Check to see if we already have this specialization. */
6351 spec = retrieve_specialization (gen_tmpl, argvec,
6352 /*class_specializations_p=*/false);
6360 /* We can see more levels of arguments than parameters if
6361 there was a specialization of a member template, like
6364 template <class T> struct S { template <class U> void f(); }
6365 template <> template <class U> void S<int>::f(U);
6367 Here, we'll be substituting into the specialization,
6368 because that's where we can find the code we actually
6369 want to generate, but we'll have enough arguments for
6370 the most general template.
6372 We also deal with the peculiar case:
6374 template <class T> struct S {
6375 template <class U> friend void f();
6377 template <class U> void f() {}
6379 template void f<double>();
6381 Here, the ARGS for the instantiation of will be {int,
6382 double}. But, we only need as many ARGS as there are
6383 levels of template parameters in CODE_PATTERN. We are
6384 careful not to get fooled into reducing the ARGS in
6387 template <class T> struct S { template <class U> void f(U); }
6388 template <class T> template <> void S<T>::f(int) {}
6390 which we can spot because the pattern will be a
6391 specialization in this case. */
6392 args_depth = TMPL_ARGS_DEPTH (args);
6394 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6395 if (args_depth > parms_depth
6396 && !DECL_TEMPLATE_SPECIALIZATION (t))
6397 args = get_innermost_template_args (args, parms_depth);
6401 /* This special case arises when we have something like this:
6403 template <class T> struct S {
6404 friend void f<int>(int, double);
6407 Here, the DECL_TI_TEMPLATE for the friend declaration
6408 will be an IDENTIFIER_NODE. We are being called from
6409 tsubst_friend_function, and we want only to create a
6410 new decl (R) with appropriate types so that we can call
6411 determine_specialization. */
6412 gen_tmpl = NULL_TREE;
6415 if (DECL_CLASS_SCOPE_P (t))
6417 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6421 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6422 complain, t, /*entering_scope=*/1);
6427 ctx = DECL_CONTEXT (t);
6429 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6430 if (type == error_mark_node)
6431 return error_mark_node;
6433 /* We do NOT check for matching decls pushed separately at this
6434 point, as they may not represent instantiations of this
6435 template, and in any case are considered separate under the
6438 DECL_USE_TEMPLATE (r) = 0;
6439 TREE_TYPE (r) = type;
6440 /* Clear out the mangled name and RTL for the instantiation. */
6441 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6442 SET_DECL_RTL (r, NULL_RTX);
6443 DECL_INITIAL (r) = NULL_TREE;
6444 DECL_CONTEXT (r) = ctx;
6446 if (member && DECL_CONV_FN_P (r))
6447 /* Type-conversion operator. Reconstruct the name, in
6448 case it's the name of one of the template's parameters. */
6449 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6451 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6453 DECL_RESULT (r) = NULL_TREE;
6455 TREE_STATIC (r) = 0;
6456 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6457 DECL_EXTERNAL (r) = 1;
6458 /* If this is an instantiation of a function with internal
6459 linkage, we already know what object file linkage will be
6460 assigned to the instantiation. */
6461 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
6462 DECL_DEFER_OUTPUT (r) = 0;
6463 TREE_CHAIN (r) = NULL_TREE;
6464 DECL_PENDING_INLINE_INFO (r) = 0;
6465 DECL_PENDING_INLINE_P (r) = 0;
6466 DECL_SAVED_TREE (r) = NULL_TREE;
6468 if (DECL_CLONED_FUNCTION (r))
6470 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6472 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6473 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6476 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6477 this in the special friend case mentioned above where
6478 GEN_TMPL is NULL. */
6481 DECL_TEMPLATE_INFO (r)
6482 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6483 SET_DECL_IMPLICIT_INSTANTIATION (r);
6484 register_specialization (r, gen_tmpl, argvec, false);
6486 /* We're not supposed to instantiate default arguments
6487 until they are called, for a template. But, for a
6490 template <class T> void f ()
6491 { extern void g(int i = T()); }
6493 we should do the substitution when the template is
6494 instantiated. We handle the member function case in
6495 instantiate_class_template since the default arguments
6496 might refer to other members of the class. */
6498 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6499 && !uses_template_parms (argvec))
6500 tsubst_default_arguments (r);
6503 /* Copy the list of befriending classes. */
6504 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6506 friends = &TREE_CHAIN (*friends))
6508 *friends = copy_node (*friends);
6509 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6514 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6516 maybe_retrofit_in_chrg (r);
6517 if (DECL_CONSTRUCTOR_P (r))
6518 grok_ctor_properties (ctx, r);
6519 /* If this is an instantiation of a member template, clone it.
6520 If it isn't, that'll be handled by
6521 clone_constructors_and_destructors. */
6522 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6523 clone_function_decl (r, /*update_method_vec_p=*/0);
6525 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r)))
6526 grok_op_properties (r, (complain & tf_error) != 0);
6528 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6529 SET_DECL_FRIEND_CONTEXT (r,
6530 tsubst (DECL_FRIEND_CONTEXT (t),
6531 args, complain, in_decl));
6540 if (DECL_TEMPLATE_PARM_P (t))
6541 SET_DECL_TEMPLATE_PARM_P (r);
6543 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6544 type = type_decays_to (type);
6545 TREE_TYPE (r) = type;
6546 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6548 if (DECL_INITIAL (r))
6550 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6551 DECL_INITIAL (r) = TREE_TYPE (r);
6553 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6557 DECL_CONTEXT (r) = NULL_TREE;
6559 if (!DECL_TEMPLATE_PARM_P (r))
6560 DECL_ARG_TYPE (r) = type_passed_as (type);
6562 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6563 complain, TREE_CHAIN (t));
6572 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6573 if (type == error_mark_node)
6574 return error_mark_node;
6575 TREE_TYPE (r) = type;
6576 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6578 /* We don't have to set DECL_CONTEXT here; it is set by
6579 finish_member_declaration. */
6580 DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args,
6582 TREE_CHAIN (r) = NULL_TREE;
6583 if (VOID_TYPE_P (type))
6584 error ("instantiation of %q+D as type %qT", r, type);
6589 /* We reach here only for member using decls. */
6590 if (DECL_DEPENDENT_P (t))
6592 r = do_class_using_decl
6593 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
6594 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
6596 r = error_mark_node;
6601 TREE_CHAIN (r) = NULL_TREE;
6608 tree argvec = NULL_TREE;
6609 tree gen_tmpl = NULL_TREE;
6611 tree tmpl = NULL_TREE;
6613 tree type = NULL_TREE;
6616 if (TREE_CODE (t) == TYPE_DECL)
6618 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6619 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6620 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6622 /* If this is the canonical decl, we don't have to
6623 mess with instantiations, and often we can't (for
6624 typename, template type parms and such). Note that
6625 TYPE_NAME is not correct for the above test if
6626 we've copied the type for a typedef. */
6627 r = TYPE_NAME (type);
6632 /* Assume this is a non-local variable. */
6635 if (TYPE_P (CP_DECL_CONTEXT (t)))
6636 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6638 in_decl, /*entering_scope=*/1);
6639 else if (DECL_NAMESPACE_SCOPE_P (t))
6640 ctx = DECL_CONTEXT (t);
6643 /* Subsequent calls to pushdecl will fill this in. */
6648 /* Check to see if we already have this specialization. */
6651 tmpl = DECL_TI_TEMPLATE (t);
6652 gen_tmpl = most_general_template (tmpl);
6653 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6654 spec = retrieve_specialization (gen_tmpl, argvec,
6655 /*class_specializations_p=*/false);
6658 spec = retrieve_local_specialization (t);
6667 if (TREE_CODE (r) == VAR_DECL)
6669 /* Even if the original location is out of scope, the
6670 newly substituted one is not. */
6671 DECL_DEAD_FOR_LOCAL (r) = 0;
6672 DECL_INITIALIZED_P (r) = 0;
6673 DECL_TEMPLATE_INSTANTIATED (r) = 0;
6674 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6675 if (type == error_mark_node)
6676 return error_mark_node;
6677 type = complete_type (type);
6678 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6679 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6680 type = check_var_type (DECL_NAME (r), type);
6682 if (DECL_HAS_VALUE_EXPR_P (t))
6684 tree ve = DECL_VALUE_EXPR (t);
6685 ve = tsubst_expr (ve, args, complain, in_decl);
6686 SET_DECL_VALUE_EXPR (r, ve);
6689 else if (DECL_SELF_REFERENCE_P (t))
6690 SET_DECL_SELF_REFERENCE_P (r);
6691 TREE_TYPE (r) = type;
6692 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6693 DECL_CONTEXT (r) = ctx;
6694 /* Clear out the mangled name and RTL for the instantiation. */
6695 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6696 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
6697 SET_DECL_RTL (r, NULL_RTX);
6698 /* The initializer must not be expanded until it is required;
6700 DECL_INITIAL (r) = NULL_TREE;
6701 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
6702 SET_DECL_RTL (r, NULL_RTX);
6703 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
6707 /* A static data member declaration is always marked
6708 external when it is declared in-class, even if an
6709 initializer is present. We mimic the non-template
6711 DECL_EXTERNAL (r) = 1;
6713 register_specialization (r, gen_tmpl, argvec, false);
6714 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
6715 SET_DECL_IMPLICIT_INSTANTIATION (r);
6718 register_local_specialization (r, t);
6720 TREE_CHAIN (r) = NULL_TREE;
6729 /* Restore the file and line information. */
6730 input_location = saved_loc;
6735 /* Substitute into the ARG_TYPES of a function type. */
6738 tsubst_arg_types (tree arg_types,
6740 tsubst_flags_t complain,
6743 tree remaining_arg_types;
6746 tree result = NULL_TREE;
6748 if (!arg_types || arg_types == void_list_node)
6751 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
6752 args, complain, in_decl);
6753 if (remaining_arg_types == error_mark_node)
6754 return error_mark_node;
6756 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
6757 if (type == error_mark_node)
6758 return error_mark_node;
6759 if (VOID_TYPE_P (type))
6761 if (complain & tf_error)
6763 error ("invalid parameter type %qT", type);
6765 error ("in declaration %q+D", in_decl);
6767 return error_mark_node;
6770 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6771 top-level qualifiers as required. */
6772 type = TYPE_MAIN_VARIANT (type_decays_to (type));
6774 /* We do not substitute into default arguments here. The standard
6775 mandates that they be instantiated only when needed, which is
6776 done in build_over_call. */
6777 default_arg = TREE_PURPOSE (arg_types);
6779 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
6781 /* We've instantiated a template before its default arguments
6782 have been parsed. This can happen for a nested template
6783 class, and is not an error unless we require the default
6784 argument in a call of this function. */
6785 result = tree_cons (default_arg, type, remaining_arg_types);
6786 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result);
6789 result = hash_tree_cons (default_arg, type, remaining_arg_types);
6794 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6795 *not* handle the exception-specification for FNTYPE, because the
6796 initial substitution of explicitly provided template parameters
6797 during argument deduction forbids substitution into the
6798 exception-specification:
6802 All references in the function type of the function template to the
6803 corresponding template parameters are replaced by the specified tem-
6804 plate argument values. If a substitution in a template parameter or
6805 in the function type of the function template results in an invalid
6806 type, type deduction fails. [Note: The equivalent substitution in
6807 exception specifications is done only when the function is instanti-
6808 ated, at which point a program is ill-formed if the substitution
6809 results in an invalid type.] */
6812 tsubst_function_type (tree t,
6814 tsubst_flags_t complain,
6821 /* The TYPE_CONTEXT is not used for function/method types. */
6822 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
6824 /* Substitute the return type. */
6825 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6826 if (return_type == error_mark_node)
6827 return error_mark_node;
6828 /* The standard does not presently indicate that creation of a
6829 function type with an invalid return type is a deduction failure.
6830 However, that is clearly analogous to creating an array of "void"
6831 or a reference to a reference. This is core issue #486. */
6832 if (TREE_CODE (return_type) == ARRAY_TYPE
6833 || TREE_CODE (return_type) == FUNCTION_TYPE)
6835 if (complain & tf_error)
6837 if (TREE_CODE (return_type) == ARRAY_TYPE)
6838 error ("function returning an array");
6840 error ("function returning a function");
6842 return error_mark_node;
6845 /* Substitute the argument types. */
6846 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
6848 if (arg_types == error_mark_node)
6849 return error_mark_node;
6851 /* Construct a new type node and return it. */
6852 if (TREE_CODE (t) == FUNCTION_TYPE)
6853 fntype = build_function_type (return_type, arg_types);
6856 tree r = TREE_TYPE (TREE_VALUE (arg_types));
6857 if (! IS_AGGR_TYPE (r))
6861 Type deduction may fail for any of the following
6864 -- Attempting to create "pointer to member of T" when T
6865 is not a class type. */
6866 if (complain & tf_error)
6867 error ("creating pointer to member function of non-class type %qT",
6869 return error_mark_node;
6872 fntype = build_method_type_directly (r, return_type,
6873 TREE_CHAIN (arg_types));
6875 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
6876 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
6881 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
6882 ARGS into that specification, and return the substituted
6883 specification. If there is no specification, return NULL_TREE. */
6886 tsubst_exception_specification (tree fntype,
6888 tsubst_flags_t complain,
6894 specs = TYPE_RAISES_EXCEPTIONS (fntype);
6895 new_specs = NULL_TREE;
6898 if (! TREE_VALUE (specs))
6904 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
6905 if (spec == error_mark_node)
6907 new_specs = add_exception_specifier (new_specs, spec, complain);
6908 specs = TREE_CHAIN (specs);
6914 /* Substitute into the PARMS of a call-declarator. */
6917 tsubst_call_declarator_parms (tree parms,
6919 tsubst_flags_t complain,
6926 if (!parms || parms == void_list_node)
6929 new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms),
6930 args, complain, in_decl);
6932 /* Figure out the type of this parameter. */
6933 type = tsubst (TREE_VALUE (parms), args, complain, in_decl);
6935 /* Figure out the default argument as well. Note that we use
6936 tsubst_expr since the default argument is really an expression. */
6937 defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl);
6939 /* Chain this parameter on to the front of those we have already
6940 processed. We don't use hash_tree_cons because that function
6941 doesn't check TREE_PARMLIST. */
6942 new_parms = tree_cons (defarg, type, new_parms);
6947 /* Take the tree structure T and replace template parameters used
6948 therein with the argument vector ARGS. IN_DECL is an associated
6949 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6950 Issue error and warning messages under control of COMPLAIN. Note
6951 that we must be relatively non-tolerant of extensions here, in
6952 order to preserve conformance; if we allow substitutions that
6953 should not be allowed, we may allow argument deductions that should
6954 not succeed, and therefore report ambiguous overload situations
6955 where there are none. In theory, we could allow the substitution,
6956 but indicate that it should have failed, and allow our caller to
6957 make sure that the right thing happens, but we don't try to do this
6960 This function is used for dealing with types, decls and the like;
6961 for expressions, use tsubst_expr or tsubst_copy. */
6964 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6968 if (t == NULL_TREE || t == error_mark_node
6969 || t == integer_type_node
6970 || t == void_type_node
6971 || t == char_type_node
6972 || t == unknown_type_node
6973 || TREE_CODE (t) == NAMESPACE_DECL)
6977 return tsubst_decl (t, args, complain);
6979 if (TREE_CODE (t) == IDENTIFIER_NODE)
6980 type = IDENTIFIER_TYPE_VALUE (t);
6982 type = TREE_TYPE (t);
6984 gcc_assert (type != unknown_type_node);
6987 && TREE_CODE (t) != TYPENAME_TYPE
6988 && TREE_CODE (t) != IDENTIFIER_NODE
6989 && TREE_CODE (t) != FUNCTION_TYPE
6990 && TREE_CODE (t) != METHOD_TYPE)
6991 type = tsubst (type, args, complain, in_decl);
6992 if (type == error_mark_node)
6993 return error_mark_node;
6995 switch (TREE_CODE (t))
7000 return tsubst_aggr_type (t, args, complain, in_decl,
7001 /*entering_scope=*/0);
7004 case IDENTIFIER_NODE:
7016 if (t == integer_type_node)
7019 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
7020 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
7024 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
7026 /* The array dimension behaves like a non-type template arg,
7027 in that we want to fold it as much as possible. */
7028 max = tsubst_template_arg (omax, args, complain, in_decl);
7029 max = fold_decl_constant_value (max);
7031 if (integer_zerop (omax))
7033 /* Still allow an explicit array of size zero. */
7035 pedwarn ("creating array with size zero");
7037 else if (integer_zerop (max)
7038 || (TREE_CODE (max) == INTEGER_CST
7039 && INT_CST_LT (max, integer_zero_node)))
7043 Type deduction may fail for any of the following
7046 Attempting to create an array with a size that is
7047 zero or negative. */
7048 if (complain & tf_error)
7049 error ("creating array with size zero (%qE)", max);
7051 return error_mark_node;
7054 return compute_array_index_type (NULL_TREE, max);
7057 case TEMPLATE_TYPE_PARM:
7058 case TEMPLATE_TEMPLATE_PARM:
7059 case BOUND_TEMPLATE_TEMPLATE_PARM:
7060 case TEMPLATE_PARM_INDEX:
7065 tree arg = NULL_TREE;
7069 gcc_assert (TREE_VEC_LENGTH (args) > 0);
7070 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7071 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
7072 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7074 idx = TEMPLATE_TYPE_IDX (t);
7075 level = TEMPLATE_TYPE_LEVEL (t);
7079 idx = TEMPLATE_PARM_IDX (t);
7080 level = TEMPLATE_PARM_LEVEL (t);
7083 levels = TMPL_ARGS_DEPTH (args);
7084 if (level <= levels)
7085 arg = TMPL_ARG (args, level, idx);
7087 if (arg == error_mark_node)
7088 return error_mark_node;
7089 else if (arg != NULL_TREE)
7091 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
7093 gcc_assert (TYPE_P (arg));
7094 return cp_build_qualified_type_real
7095 (arg, cp_type_quals (arg) | cp_type_quals (t),
7096 complain | tf_ignore_bad_quals);
7098 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7100 /* We are processing a type constructed from a
7101 template template parameter. */
7102 tree argvec = tsubst (TYPE_TI_ARGS (t),
7103 args, complain, in_decl);
7104 if (argvec == error_mark_node)
7105 return error_mark_node;
7107 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
7108 are resolving nested-types in the signature of a
7109 member function templates. Otherwise ARG is a
7110 TEMPLATE_DECL and is the real template to be
7112 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
7113 arg = TYPE_NAME (arg);
7115 r = lookup_template_class (arg,
7118 /*entering_scope=*/0,
7120 return cp_build_qualified_type_real
7121 (r, TYPE_QUALS (t), complain);
7124 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
7129 /* This can happen during the attempted tsubst'ing in
7130 unify. This means that we don't yet have any information
7131 about the template parameter in question. */
7134 /* If we get here, we must have been looking at a parm for a
7135 more deeply nested template. Make a new version of this
7136 template parameter, but with a lower level. */
7137 switch (TREE_CODE (t))
7139 case TEMPLATE_TYPE_PARM:
7140 case TEMPLATE_TEMPLATE_PARM:
7141 case BOUND_TEMPLATE_TEMPLATE_PARM:
7142 if (cp_type_quals (t))
7144 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
7145 r = cp_build_qualified_type_real
7146 (r, cp_type_quals (t),
7147 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7148 ? tf_ignore_bad_quals : 0));
7153 TEMPLATE_TYPE_PARM_INDEX (r)
7154 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
7156 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
7157 TYPE_MAIN_VARIANT (r) = r;
7158 TYPE_POINTER_TO (r) = NULL_TREE;
7159 TYPE_REFERENCE_TO (r) = NULL_TREE;
7161 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7163 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
7165 if (argvec == error_mark_node)
7166 return error_mark_node;
7168 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
7169 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
7174 case TEMPLATE_PARM_INDEX:
7175 r = reduce_template_parm_level (t, type, levels);
7187 tree purpose, value, chain;
7189 if (t == void_list_node)
7192 purpose = TREE_PURPOSE (t);
7195 purpose = tsubst (purpose, args, complain, in_decl);
7196 if (purpose == error_mark_node)
7197 return error_mark_node;
7199 value = TREE_VALUE (t);
7202 value = tsubst (value, args, complain, in_decl);
7203 if (value == error_mark_node)
7204 return error_mark_node;
7206 chain = TREE_CHAIN (t);
7207 if (chain && chain != void_type_node)
7209 chain = tsubst (chain, args, complain, in_decl);
7210 if (chain == error_mark_node)
7211 return error_mark_node;
7213 if (purpose == TREE_PURPOSE (t)
7214 && value == TREE_VALUE (t)
7215 && chain == TREE_CHAIN (t))
7217 return hash_tree_cons (purpose, value, chain);
7221 /* We should never be tsubsting a binfo. */
7225 /* A vector of template arguments. */
7227 return tsubst_template_args (t, args, complain, in_decl);
7230 case REFERENCE_TYPE:
7232 enum tree_code code;
7234 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
7237 code = TREE_CODE (t);
7242 Type deduction may fail for any of the following
7245 -- Attempting to create a pointer to reference type.
7246 -- Attempting to create a reference to a reference type or
7247 a reference to void. */
7248 if (TREE_CODE (type) == REFERENCE_TYPE
7249 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
7251 static location_t last_loc;
7253 /* We keep track of the last time we issued this error
7254 message to avoid spewing a ton of messages during a
7255 single bad template instantiation. */
7256 if (complain & tf_error
7257 #ifdef USE_MAPPED_LOCATION
7258 && last_loc != input_location
7260 && (last_loc.line != input_line
7261 || last_loc.file != input_filename)
7265 if (TREE_CODE (type) == VOID_TYPE)
7266 error ("forming reference to void");
7268 error ("forming %s to reference type %qT",
7269 (code == POINTER_TYPE) ? "pointer" : "reference",
7271 last_loc = input_location;
7274 return error_mark_node;
7276 else if (code == POINTER_TYPE)
7278 r = build_pointer_type (type);
7279 if (TREE_CODE (type) == METHOD_TYPE)
7280 r = build_ptrmemfunc_type (r);
7283 r = build_reference_type (type);
7284 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7286 if (r != error_mark_node)
7287 /* Will this ever be needed for TYPE_..._TO values? */
7294 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7295 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7299 Type deduction may fail for any of the following
7302 -- Attempting to create "pointer to member of T" when T
7303 is not a class type. */
7304 if (complain & tf_error)
7305 error ("creating pointer to member of non-class type %qT", r);
7306 return error_mark_node;
7308 if (TREE_CODE (type) == REFERENCE_TYPE)
7310 if (complain & tf_error)
7311 error ("creating pointer to member reference type %qT", type);
7312 return error_mark_node;
7314 if (TREE_CODE (type) == VOID_TYPE)
7316 if (complain & tf_error)
7317 error ("creating pointer to member of type void");
7318 return error_mark_node;
7320 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
7321 if (TREE_CODE (type) == FUNCTION_TYPE)
7323 /* The type of the implicit object parameter gets its
7324 cv-qualifiers from the FUNCTION_TYPE. */
7326 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
7327 cp_type_quals (type));
7329 method_type = build_method_type_directly (this_type,
7331 TYPE_ARG_TYPES (type));
7332 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
7333 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
7337 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7346 fntype = tsubst_function_type (t, args, complain, in_decl);
7347 if (fntype == error_mark_node)
7348 return error_mark_node;
7350 /* Substitute the exception specification. */
7351 specs = tsubst_exception_specification (t, args, complain,
7353 if (specs == error_mark_node)
7354 return error_mark_node;
7356 fntype = build_exception_variant (fntype, specs);
7361 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7362 if (domain == error_mark_node)
7363 return error_mark_node;
7365 /* As an optimization, we avoid regenerating the array type if
7366 it will obviously be the same as T. */
7367 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7370 /* These checks should match the ones in grokdeclarator.
7374 The deduction may fail for any of the following reasons:
7376 -- Attempting to create an array with an element type that
7377 is void, a function type, or a reference type, or [DR337]
7378 an abstract class type. */
7379 if (TREE_CODE (type) == VOID_TYPE
7380 || TREE_CODE (type) == FUNCTION_TYPE
7381 || TREE_CODE (type) == REFERENCE_TYPE)
7383 if (complain & tf_error)
7384 error ("creating array of %qT", type);
7385 return error_mark_node;
7387 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7389 if (complain & tf_error)
7390 error ("creating array of %qT, which is an abstract class type",
7392 return error_mark_node;
7395 r = build_cplus_array_type (type, domain);
7402 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7403 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7405 if (e1 == error_mark_node || e2 == error_mark_node)
7406 return error_mark_node;
7408 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
7414 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7415 if (e == error_mark_node)
7416 return error_mark_node;
7418 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
7423 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7424 in_decl, /*entering_scope=*/1);
7425 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7428 if (ctx == error_mark_node || f == error_mark_node)
7429 return error_mark_node;
7431 if (!IS_AGGR_TYPE (ctx))
7433 if (complain & tf_error)
7434 error ("%qT is not a class, struct, or union type", ctx);
7435 return error_mark_node;
7437 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7439 /* Normally, make_typename_type does not require that the CTX
7440 have complete type in order to allow things like:
7442 template <class T> struct S { typename S<T>::X Y; };
7444 But, such constructs have already been resolved by this
7445 point, so here CTX really should have complete type, unless
7446 it's a partial instantiation. */
7447 ctx = complete_type (ctx);
7448 if (!COMPLETE_TYPE_P (ctx))
7450 if (complain & tf_error)
7451 cxx_incomplete_type_error (NULL_TREE, ctx);
7452 return error_mark_node;
7456 f = make_typename_type (ctx, f, typename_type,
7457 (complain & tf_error) | tf_keep_type_decl);
7458 if (f == error_mark_node)
7460 if (TREE_CODE (f) == TYPE_DECL)
7462 complain |= tf_ignore_bad_quals;
7466 if (TREE_CODE (f) != TYPENAME_TYPE)
7468 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
7469 error ("%qT resolves to %qT, which is not an enumeration type",
7471 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
7472 error ("%qT resolves to %qT, which is is not a class type",
7476 return cp_build_qualified_type_real
7477 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7480 case UNBOUND_CLASS_TEMPLATE:
7482 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7483 in_decl, /*entering_scope=*/1);
7484 tree name = TYPE_IDENTIFIER (t);
7485 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
7487 if (ctx == error_mark_node || name == error_mark_node)
7488 return error_mark_node;
7491 parm_list = tsubst_template_parms (parm_list, args, complain);
7492 return make_unbound_class_template (ctx, name, parm_list, complain);
7502 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7503 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl);
7504 if (e1 == error_mark_node || e2 == error_mark_node)
7505 return error_mark_node;
7507 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
7512 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7513 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7514 if (e1 == error_mark_node || e2 == error_mark_node)
7515 return error_mark_node;
7517 return build_nt (TREE_CODE (t), e1, e2);
7524 type = finish_typeof (tsubst_expr (TYPEOF_TYPE_EXPR (t), args,
7525 complain, in_decl));
7526 return cp_build_qualified_type_real (type,
7528 | cp_type_quals (type),
7533 sorry ("use of %qs in template",
7534 tree_code_name [(int) TREE_CODE (t)]);
7535 return error_mark_node;
7539 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7540 type of the expression on the left-hand side of the "." or "->"
7544 tsubst_baselink (tree baselink, tree object_type,
7545 tree args, tsubst_flags_t complain, tree in_decl)
7548 tree qualifying_scope;
7550 tree template_args = 0;
7551 bool template_id_p = false;
7553 /* A baselink indicates a function from a base class. The
7554 BASELINK_ACCESS_BINFO and BASELINK_BINFO are going to have
7555 non-dependent types; otherwise, the lookup could not have
7556 succeeded. However, they may indicate bases of the template
7557 class, rather than the instantiated class.
7559 In addition, lookups that were not ambiguous before may be
7560 ambiguous now. Therefore, we perform the lookup again. */
7561 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7562 fns = BASELINK_FUNCTIONS (baselink);
7563 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7565 template_id_p = true;
7566 template_args = TREE_OPERAND (fns, 1);
7567 fns = TREE_OPERAND (fns, 0);
7569 template_args = tsubst_template_args (template_args, args,
7572 name = DECL_NAME (get_first_fn (fns));
7573 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7575 /* If lookup found a single function, mark it as used at this
7576 point. (If it lookup found multiple functions the one selected
7577 later by overload resolution will be marked as used at that
7579 if (BASELINK_P (baselink))
7580 fns = BASELINK_FUNCTIONS (baselink);
7581 if (!template_id_p && !really_overloaded_fn (fns))
7582 mark_used (OVL_CURRENT (fns));
7584 /* Add back the template arguments, if present. */
7585 if (BASELINK_P (baselink) && template_id_p)
7586 BASELINK_FUNCTIONS (baselink)
7587 = build_nt (TEMPLATE_ID_EXPR,
7588 BASELINK_FUNCTIONS (baselink),
7592 object_type = current_class_type;
7593 return adjust_result_of_qualified_name_lookup (baselink,
7598 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7599 true if the qualified-id will be a postfix-expression in-and-of
7600 itself; false if more of the postfix-expression follows the
7601 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7605 tsubst_qualified_id (tree qualified_id, tree args,
7606 tsubst_flags_t complain, tree in_decl,
7607 bool done, bool address_p)
7615 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
7617 /* Figure out what name to look up. */
7618 name = TREE_OPERAND (qualified_id, 1);
7619 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7622 template_args = TREE_OPERAND (name, 1);
7624 template_args = tsubst_template_args (template_args, args,
7626 name = TREE_OPERAND (name, 0);
7630 is_template = false;
7631 template_args = NULL_TREE;
7634 /* Substitute into the qualifying scope. When there are no ARGS, we
7635 are just trying to simplify a non-dependent expression. In that
7636 case the qualifying scope may be dependent, and, in any case,
7637 substituting will not help. */
7638 scope = TREE_OPERAND (qualified_id, 0);
7641 scope = tsubst (scope, args, complain, in_decl);
7642 expr = tsubst_copy (name, args, complain, in_decl);
7647 if (dependent_type_p (scope))
7648 return build_nt (SCOPE_REF, scope, expr);
7650 if (!BASELINK_P (name) && !DECL_P (expr))
7652 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7653 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7654 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7656 if (complain & tf_error)
7658 error ("dependent-name %qE is parsed as a non-type, but "
7659 "instantiation yields a type", qualified_id);
7660 inform ("say %<typename %E%> if a type is meant", qualified_id);
7662 return error_mark_node;
7668 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7670 /* Remember that there was a reference to this entity. */
7674 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
7676 if (complain & tf_error)
7677 qualified_name_lookup_error (scope,
7678 TREE_OPERAND (qualified_id, 1),
7680 return error_mark_node;
7684 expr = lookup_template_function (expr, template_args);
7686 if (expr == error_mark_node && complain & tf_error)
7687 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
7689 else if (TYPE_P (scope))
7691 expr = (adjust_result_of_qualified_name_lookup
7692 (expr, scope, current_class_type));
7693 expr = finish_qualified_id_expr (scope, expr, done, address_p);
7696 if (TREE_CODE (expr) != SCOPE_REF)
7697 expr = convert_from_reference (expr);
7702 /* Like tsubst, but deals with expressions. This function just replaces
7703 template parms; to finish processing the resultant expression, use
7707 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7709 enum tree_code code;
7712 if (t == NULL_TREE || t == error_mark_node)
7715 code = TREE_CODE (t);
7720 r = retrieve_local_specialization (t);
7721 gcc_assert (r != NULL);
7730 if (DECL_TEMPLATE_PARM_P (t))
7731 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
7732 /* There is no need to substitute into namespace-scope
7734 if (DECL_NAMESPACE_SCOPE_P (t))
7736 /* If ARGS is NULL, then T is known to be non-dependent. */
7737 if (args == NULL_TREE)
7738 return integral_constant_value (t);
7740 /* Unfortunately, we cannot just call lookup_name here.
7743 template <int I> int f() {
7745 struct S { void g() { E e = a; } };
7748 When we instantiate f<7>::S::g(), say, lookup_name is not
7749 clever enough to find f<7>::a. */
7751 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
7752 /*entering_scope=*/0);
7754 for (v = TYPE_VALUES (enum_type);
7757 if (TREE_PURPOSE (v) == DECL_NAME (t))
7758 return TREE_VALUE (v);
7760 /* We didn't find the name. That should never happen; if
7761 name-lookup found it during preliminary parsing, we
7762 should find it again here during instantiation. */
7768 if (DECL_CONTEXT (t))
7772 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
7773 /*entering_scope=*/1);
7774 if (ctx != DECL_CONTEXT (t))
7776 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
7779 if (complain & tf_error)
7780 error ("using invalid field %qD", t);
7781 return error_mark_node;
7791 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
7792 || local_variable_p (t))
7793 t = tsubst (t, args, complain, in_decl);
7798 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
7801 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7802 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
7803 args, complain, in_decl);
7804 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
7805 return tsubst (t, args, complain, in_decl);
7806 else if (DECL_CLASS_SCOPE_P (t)
7807 && uses_template_parms (DECL_CONTEXT (t)))
7809 /* Template template argument like the following example need
7812 template <template <class> class TT> struct C {};
7813 template <class T> struct D {
7814 template <class U> struct E {};
7819 We are processing the template argument `E' in #1 for
7820 the template instantiation #2. Originally, `E' is a
7821 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
7822 have to substitute this with one having context `D<int>'. */
7824 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
7825 return lookup_field (context, DECL_NAME(t), 0, false);
7828 /* Ordinary template template argument. */
7832 case REINTERPRET_CAST_EXPR:
7833 case CONST_CAST_EXPR:
7834 case STATIC_CAST_EXPR:
7835 case DYNAMIC_CAST_EXPR:
7838 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7839 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7843 case TRUTH_NOT_EXPR:
7846 case UNARY_PLUS_EXPR: /* Unary + */
7855 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7856 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7863 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
7864 name = TREE_OPERAND (t, 1);
7865 if (TREE_CODE (name) == BIT_NOT_EXPR)
7867 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7869 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7871 else if (TREE_CODE (name) == SCOPE_REF
7872 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
7874 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
7876 name = TREE_OPERAND (name, 1);
7877 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7879 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7880 name = build_nt (SCOPE_REF, base, name);
7882 else if (TREE_CODE (name) == BASELINK)
7883 name = tsubst_baselink (name,
7884 non_reference (TREE_TYPE (object)),
7888 name = tsubst_copy (name, args, complain, in_decl);
7889 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
7895 case TRUNC_DIV_EXPR:
7897 case FLOOR_DIV_EXPR:
7898 case ROUND_DIV_EXPR:
7899 case EXACT_DIV_EXPR:
7903 case TRUNC_MOD_EXPR:
7904 case FLOOR_MOD_EXPR:
7905 case TRUTH_ANDIF_EXPR:
7906 case TRUTH_ORIF_EXPR:
7907 case TRUTH_AND_EXPR:
7925 case PREDECREMENT_EXPR:
7926 case PREINCREMENT_EXPR:
7927 case POSTDECREMENT_EXPR:
7928 case POSTINCREMENT_EXPR:
7930 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7931 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7936 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7937 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7938 NULL_TREE, NULL_TREE);
7941 return build_nt (code,
7942 tsubst_copy (TREE_OPERAND (t, 0), args,
7944 tsubst_copy (TREE_OPERAND (t, 1), args, complain,
7950 case PSEUDO_DTOR_EXPR:
7953 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7954 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7955 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7956 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
7963 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7964 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7965 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7966 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
7973 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7974 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7975 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
7976 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
7980 case TEMPLATE_ID_EXPR:
7982 /* Substituted template arguments */
7983 tree fn = TREE_OPERAND (t, 0);
7984 tree targs = TREE_OPERAND (t, 1);
7986 fn = tsubst_copy (fn, args, complain, in_decl);
7988 targs = tsubst_template_args (targs, args, complain, in_decl);
7990 return lookup_template_function (fn, targs);
7995 tree purpose, value, chain;
7997 if (t == void_list_node)
8000 purpose = TREE_PURPOSE (t);
8002 purpose = tsubst_copy (purpose, args, complain, in_decl);
8003 value = TREE_VALUE (t);
8005 value = tsubst_copy (value, args, complain, in_decl);
8006 chain = TREE_CHAIN (t);
8007 if (chain && chain != void_type_node)
8008 chain = tsubst_copy (chain, args, complain, in_decl);
8009 if (purpose == TREE_PURPOSE (t)
8010 && value == TREE_VALUE (t)
8011 && chain == TREE_CHAIN (t))
8013 return tree_cons (purpose, value, chain);
8020 case TEMPLATE_TYPE_PARM:
8021 case TEMPLATE_TEMPLATE_PARM:
8022 case BOUND_TEMPLATE_TEMPLATE_PARM:
8023 case TEMPLATE_PARM_INDEX:
8025 case REFERENCE_TYPE:
8031 case UNBOUND_CLASS_TEMPLATE:
8034 return tsubst (t, args, complain, in_decl);
8036 case IDENTIFIER_NODE:
8037 if (IDENTIFIER_TYPENAME_P (t))
8039 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8040 return mangle_conv_op_name_for_type (new_type);
8046 /* This is handled by tsubst_copy_and_build. */
8050 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
8052 tsubst (TREE_TYPE (t), args, complain, in_decl));
8054 case CLEANUP_POINT_EXPR:
8055 /* We shouldn't have built any of these during initial template
8056 generation. Instead, they should be built during instantiation
8057 in response to the saved STMT_IS_FULL_EXPR_P setting. */
8065 /* Like tsubst_copy for expressions, etc. but also does semantic
8069 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8073 if (t == NULL_TREE || t == error_mark_node)
8076 if (EXPR_HAS_LOCATION (t))
8077 input_location = EXPR_LOCATION (t);
8078 if (STATEMENT_CODE_P (TREE_CODE (t)))
8079 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
8081 switch (TREE_CODE (t))
8083 case STATEMENT_LIST:
8085 tree_stmt_iterator i;
8086 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
8087 tsubst_expr (tsi_stmt (i), args, complain, in_decl);
8091 case CTOR_INITIALIZER:
8092 finish_mem_initializers (tsubst_initializer_list
8093 (TREE_OPERAND (t, 0), args));
8097 finish_return_stmt (tsubst_expr (TREE_OPERAND (t, 0),
8098 args, complain, in_decl));
8102 tmp = tsubst_expr (EXPR_STMT_EXPR (t), args, complain, in_decl);
8103 if (EXPR_STMT_STMT_EXPR_RESULT (t))
8104 finish_stmt_expr_expr (tmp, cur_stmt_expr);
8106 finish_expr_stmt (tmp);
8110 do_using_directive (tsubst_expr (USING_STMT_NAMESPACE (t),
8111 args, complain, in_decl));
8119 decl = DECL_EXPR_DECL (t);
8120 if (TREE_CODE (decl) == LABEL_DECL)
8121 finish_label_decl (DECL_NAME (decl));
8122 else if (TREE_CODE (decl) == USING_DECL)
8124 tree scope = USING_DECL_SCOPE (decl);
8125 tree name = DECL_NAME (decl);
8128 scope = tsubst_expr (scope, args, complain, in_decl);
8129 decl = lookup_qualified_name (scope, name,
8130 /*is_type_p=*/false,
8131 /*complain=*/false);
8132 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
8133 qualified_name_lookup_error (scope, name, decl);
8135 do_local_using_decl (decl, scope, name);
8139 init = DECL_INITIAL (decl);
8140 decl = tsubst (decl, args, complain, in_decl);
8141 if (decl != error_mark_node)
8144 DECL_INITIAL (decl) = error_mark_node;
8145 /* By marking the declaration as instantiated, we avoid
8146 trying to instantiate it. Since instantiate_decl can't
8147 handle local variables, and since we've already done
8148 all that needs to be done, that's the right thing to
8150 if (TREE_CODE (decl) == VAR_DECL)
8151 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8152 if (TREE_CODE (decl) == VAR_DECL
8153 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
8154 /* Anonymous aggregates are a special case. */
8155 finish_anon_union (decl);
8158 maybe_push_decl (decl);
8159 if (TREE_CODE (decl) == VAR_DECL
8160 && DECL_PRETTY_FUNCTION_P (decl))
8162 /* For __PRETTY_FUNCTION__ we have to adjust the
8164 const char *const name
8165 = cxx_printable_name (current_function_decl, 2);
8166 init = cp_fname_init (name, &TREE_TYPE (decl));
8169 init = tsubst_expr (init, args, complain, in_decl);
8170 cp_finish_decl (decl, init, NULL_TREE, 0);
8175 /* A DECL_EXPR can also be used as an expression, in the condition
8176 clause of an if/for/while construct. */
8181 stmt = begin_for_stmt ();
8182 tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl);
8183 finish_for_init_stmt (stmt);
8184 tmp = tsubst_expr (FOR_COND (t), args, complain, in_decl);
8185 finish_for_cond (tmp, stmt);
8186 tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
8187 finish_for_expr (tmp, stmt);
8188 tsubst_expr (FOR_BODY (t), args, complain, in_decl);
8189 finish_for_stmt (stmt);
8193 stmt = begin_while_stmt ();
8194 tmp = tsubst_expr (WHILE_COND (t), args, complain, in_decl);
8195 finish_while_stmt_cond (tmp, stmt);
8196 tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
8197 finish_while_stmt (stmt);
8201 stmt = begin_do_stmt ();
8202 tsubst_expr (DO_BODY (t), args, complain, in_decl);
8203 finish_do_body (stmt);
8204 tmp = tsubst_expr (DO_COND (t), args, complain, in_decl);
8205 finish_do_stmt (tmp, stmt);
8209 stmt = begin_if_stmt ();
8210 tmp = tsubst_expr (IF_COND (t), args, complain, in_decl);
8211 finish_if_stmt_cond (tmp, stmt);
8212 tsubst_expr (THEN_CLAUSE (t), args, complain, in_decl);
8213 finish_then_clause (stmt);
8215 if (ELSE_CLAUSE (t))
8217 begin_else_clause (stmt);
8218 tsubst_expr (ELSE_CLAUSE (t), args, complain, in_decl);
8219 finish_else_clause (stmt);
8222 finish_if_stmt (stmt);
8226 if (BIND_EXPR_BODY_BLOCK (t))
8227 stmt = begin_function_body ();
8229 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
8230 ? BCS_TRY_BLOCK : 0);
8232 tsubst_expr (BIND_EXPR_BODY (t), args, complain, in_decl);
8234 if (BIND_EXPR_BODY_BLOCK (t))
8235 finish_function_body (stmt);
8237 finish_compound_stmt (stmt);
8241 finish_break_stmt ();
8245 finish_continue_stmt ();
8249 stmt = begin_switch_stmt ();
8250 tmp = tsubst_expr (SWITCH_STMT_COND (t), args, complain, in_decl);
8251 finish_switch_cond (tmp, stmt);
8252 tsubst_expr (SWITCH_STMT_BODY (t), args, complain, in_decl);
8253 finish_switch_stmt (stmt);
8256 case CASE_LABEL_EXPR:
8257 finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl),
8258 tsubst_expr (CASE_HIGH (t), args, complain,
8263 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
8267 tmp = GOTO_DESTINATION (t);
8268 if (TREE_CODE (tmp) != LABEL_DECL)
8269 /* Computed goto's must be tsubst'd into. On the other hand,
8270 non-computed gotos must not be; the identifier in question
8271 will have no binding. */
8272 tmp = tsubst_expr (tmp, args, complain, in_decl);
8274 tmp = DECL_NAME (tmp);
8275 finish_goto_stmt (tmp);
8279 tmp = finish_asm_stmt
8280 (ASM_VOLATILE_P (t),
8281 tsubst_expr (ASM_STRING (t), args, complain, in_decl),
8282 tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl),
8283 tsubst_expr (ASM_INPUTS (t), args, complain, in_decl),
8284 tsubst_expr (ASM_CLOBBERS (t), args, complain, in_decl));
8286 tree asm_expr = tmp;
8287 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
8288 asm_expr = TREE_OPERAND (asm_expr, 0);
8289 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
8296 stmt = begin_try_block ();
8297 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
8298 finish_cleanup_try_block (stmt);
8299 finish_cleanup (tsubst_expr (TRY_HANDLERS (t), args,
8305 if (FN_TRY_BLOCK_P (t))
8306 stmt = begin_function_try_block ();
8308 stmt = begin_try_block ();
8310 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
8312 if (FN_TRY_BLOCK_P (t))
8313 finish_function_try_block (stmt);
8315 finish_try_block (stmt);
8317 tsubst_expr (TRY_HANDLERS (t), args, complain, in_decl);
8318 if (FN_TRY_BLOCK_P (t))
8319 finish_function_handler_sequence (stmt);
8321 finish_handler_sequence (stmt);
8329 stmt = begin_handler ();
8330 if (HANDLER_PARMS (t))
8332 decl = HANDLER_PARMS (t);
8333 decl = tsubst (decl, args, complain, in_decl);
8334 /* Prevent instantiate_decl from trying to instantiate
8335 this variable. We've already done all that needs to be
8337 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8341 finish_handler_parms (decl, stmt);
8342 tsubst_expr (HANDLER_BODY (t), args, complain, in_decl);
8343 finish_handler (stmt);
8348 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8352 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
8354 return tsubst_copy_and_build (t, args, complain, in_decl,
8355 /*function_p=*/false);
8361 /* T is a postfix-expression that is not being used in a function
8362 call. Return the substituted version of T. */
8365 tsubst_non_call_postfix_expression (tree t, tree args,
8366 tsubst_flags_t complain,
8369 if (TREE_CODE (t) == SCOPE_REF)
8370 t = tsubst_qualified_id (t, args, complain, in_decl,
8371 /*done=*/false, /*address_p=*/false);
8373 t = tsubst_copy_and_build (t, args, complain, in_decl,
8374 /*function_p=*/false);
8379 /* Like tsubst but deals with expressions and performs semantic
8380 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8383 tsubst_copy_and_build (tree t,
8385 tsubst_flags_t complain,
8389 #define RECUR(NODE) \
8390 tsubst_copy_and_build (NODE, args, complain, in_decl, /*function_p=*/false)
8394 if (t == NULL_TREE || t == error_mark_node)
8397 switch (TREE_CODE (t))
8402 case IDENTIFIER_NODE:
8406 tree qualifying_class;
8407 bool non_integral_constant_expression_p;
8408 const char *error_msg;
8410 if (IDENTIFIER_TYPENAME_P (t))
8412 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8413 t = mangle_conv_op_name_for_type (new_type);
8416 /* Look up the name. */
8417 decl = lookup_name (t, 0);
8419 /* By convention, expressions use ERROR_MARK_NODE to indicate
8420 failure, not NULL_TREE. */
8421 if (decl == NULL_TREE)
8422 decl = error_mark_node;
8424 decl = finish_id_expression (t, decl, NULL_TREE,
8427 /*integral_constant_expression_p=*/false,
8428 /*allow_non_integral_constant_expression_p=*/false,
8429 &non_integral_constant_expression_p,
8433 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8434 decl = unqualified_name_lookup_error (decl);
8438 case TEMPLATE_ID_EXPR:
8441 tree template = RECUR (TREE_OPERAND (t, 0));
8442 tree targs = TREE_OPERAND (t, 1);
8445 targs = tsubst_template_args (targs, args, complain, in_decl);
8447 if (TREE_CODE (template) == COMPONENT_REF)
8449 object = TREE_OPERAND (template, 0);
8450 template = TREE_OPERAND (template, 1);
8454 template = lookup_template_function (template, targs);
8457 return build3 (COMPONENT_REF, TREE_TYPE (template),
8458 object, template, NULL_TREE);
8465 tree r = RECUR (TREE_OPERAND (t, 0));
8467 if (REFERENCE_REF_P (t))
8469 /* A type conversion to reference type will be enclosed in
8470 such an indirect ref, but the substitution of the cast
8471 will have also added such an indirect ref. */
8472 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
8473 r = convert_from_reference (r);
8476 r = build_x_indirect_ref (r, "unary *");
8482 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8483 RECUR (TREE_OPERAND (t, 0)));
8486 return build_functional_cast
8487 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8488 RECUR (TREE_OPERAND (t, 0)));
8490 case REINTERPRET_CAST_EXPR:
8491 return build_reinterpret_cast
8492 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8493 RECUR (TREE_OPERAND (t, 0)));
8495 case CONST_CAST_EXPR:
8496 return build_const_cast
8497 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8498 RECUR (TREE_OPERAND (t, 0)));
8500 case DYNAMIC_CAST_EXPR:
8501 return build_dynamic_cast
8502 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8503 RECUR (TREE_OPERAND (t, 0)));
8505 case STATIC_CAST_EXPR:
8506 return build_static_cast
8507 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8508 RECUR (TREE_OPERAND (t, 0)));
8510 case POSTDECREMENT_EXPR:
8511 case POSTINCREMENT_EXPR:
8512 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8513 args, complain, in_decl);
8514 return build_x_unary_op (TREE_CODE (t), op1);
8516 case PREDECREMENT_EXPR:
8517 case PREINCREMENT_EXPR:
8521 case TRUTH_NOT_EXPR:
8522 case UNARY_PLUS_EXPR: /* Unary + */
8525 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
8528 op1 = TREE_OPERAND (t, 0);
8529 if (TREE_CODE (op1) == SCOPE_REF)
8530 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
8531 /*done=*/true, /*address_p=*/true);
8533 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
8535 if (TREE_CODE (op1) == LABEL_DECL)
8536 return finish_label_address_expr (DECL_NAME (op1));
8537 return build_x_unary_op (ADDR_EXPR, op1);
8542 case TRUNC_DIV_EXPR:
8544 case FLOOR_DIV_EXPR:
8545 case ROUND_DIV_EXPR:
8546 case EXACT_DIV_EXPR:
8550 case TRUNC_MOD_EXPR:
8551 case FLOOR_MOD_EXPR:
8552 case TRUTH_ANDIF_EXPR:
8553 case TRUTH_ORIF_EXPR:
8554 case TRUTH_AND_EXPR:
8570 return build_x_binary_op
8572 RECUR (TREE_OPERAND (t, 0)),
8573 RECUR (TREE_OPERAND (t, 1)),
8574 /*overloaded_p=*/NULL);
8577 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
8578 /*address_p=*/false);
8580 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8581 args, complain, in_decl);
8582 return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)),
8583 /*overloaded_p=*/NULL);
8587 op1 = TREE_OPERAND (t, 0);
8590 /* When there are no ARGS, we are trying to evaluate a
8591 non-dependent expression from the parser. Trying to do
8592 the substitutions may not work. */
8594 op1 = TREE_TYPE (op1);
8603 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
8605 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
8609 tree r = build_x_modify_expr
8610 (RECUR (TREE_OPERAND (t, 0)),
8611 TREE_CODE (TREE_OPERAND (t, 1)),
8612 RECUR (TREE_OPERAND (t, 2)));
8613 /* TREE_NO_WARNING must be set if either the expression was
8614 parenthesized or it uses an operator such as >>= rather
8615 than plain assignment. In the former case, it was already
8616 set and must be copied. In the latter case,
8617 build_x_modify_expr sets it and it must not be reset
8619 if (TREE_NO_WARNING (t))
8620 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
8625 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8626 args, complain, in_decl);
8627 /* Remember that there was a reference to this entity. */
8630 return build_x_arrow (op1);
8634 (RECUR (TREE_OPERAND (t, 0)),
8635 RECUR (TREE_OPERAND (t, 1)),
8636 RECUR (TREE_OPERAND (t, 2)),
8637 RECUR (TREE_OPERAND (t, 3)),
8638 NEW_EXPR_USE_GLOBAL (t));
8641 return delete_sanity
8642 (RECUR (TREE_OPERAND (t, 0)),
8643 RECUR (TREE_OPERAND (t, 1)),
8644 DELETE_EXPR_USE_VEC (t),
8645 DELETE_EXPR_USE_GLOBAL (t));
8648 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
8649 RECUR (TREE_OPERAND (t, 1)));
8658 function = TREE_OPERAND (t, 0);
8659 /* When we parsed the expression, we determined whether or
8660 not Koenig lookup should be performed. */
8661 koenig_p = KOENIG_LOOKUP_P (t);
8662 if (TREE_CODE (function) == SCOPE_REF)
8665 function = tsubst_qualified_id (function, args, complain, in_decl,
8667 /*address_p=*/false);
8671 qualified_p = (TREE_CODE (function) == COMPONENT_REF
8672 && (TREE_CODE (TREE_OPERAND (function, 1))
8674 function = tsubst_copy_and_build (function, args, complain,
8677 if (BASELINK_P (function))
8681 call_args = RECUR (TREE_OPERAND (t, 1));
8683 /* We do not perform argument-dependent lookup if normal
8684 lookup finds a non-function, in accordance with the
8685 expected resolution of DR 218. */
8687 && ((is_overloaded_fn (function)
8688 /* If lookup found a member function, the Koenig lookup is
8689 not appropriate, even if an unqualified-name was used
8690 to denote the function. */
8691 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
8692 || TREE_CODE (function) == IDENTIFIER_NODE))
8693 function = perform_koenig_lookup (function, call_args);
8695 if (TREE_CODE (function) == IDENTIFIER_NODE)
8697 unqualified_name_lookup_error (function);
8698 return error_mark_node;
8701 /* Remember that there was a reference to this entity. */
8702 if (DECL_P (function))
8703 mark_used (function);
8705 if (TREE_CODE (function) == OFFSET_REF)
8706 return build_offset_ref_call_from_tree (function, call_args);
8707 if (TREE_CODE (function) == COMPONENT_REF)
8709 if (!BASELINK_P (TREE_OPERAND (function, 1)))
8710 return finish_call_expr (function, call_args,
8711 /*disallow_virtual=*/false,
8712 /*koenig_p=*/false);
8714 return (build_new_method_call
8715 (TREE_OPERAND (function, 0),
8716 TREE_OPERAND (function, 1),
8717 call_args, NULL_TREE,
8718 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL));
8720 return finish_call_expr (function, call_args,
8721 /*disallow_virtual=*/qualified_p,
8726 return build_x_conditional_expr
8727 (RECUR (TREE_OPERAND (t, 0)),
8728 RECUR (TREE_OPERAND (t, 1)),
8729 RECUR (TREE_OPERAND (t, 2)));
8731 case PSEUDO_DTOR_EXPR:
8732 return finish_pseudo_destructor_expr
8733 (RECUR (TREE_OPERAND (t, 0)),
8734 RECUR (TREE_OPERAND (t, 1)),
8735 RECUR (TREE_OPERAND (t, 2)));
8739 tree purpose, value, chain;
8741 if (t == void_list_node)
8744 purpose = TREE_PURPOSE (t);
8746 purpose = RECUR (purpose);
8747 value = TREE_VALUE (t);
8749 value = RECUR (value);
8750 chain = TREE_CHAIN (t);
8751 if (chain && chain != void_type_node)
8752 chain = RECUR (chain);
8753 if (purpose == TREE_PURPOSE (t)
8754 && value == TREE_VALUE (t)
8755 && chain == TREE_CHAIN (t))
8757 return tree_cons (purpose, value, chain);
8765 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8766 args, complain, in_decl);
8767 /* Remember that there was a reference to this entity. */
8768 if (DECL_P (object))
8771 member = TREE_OPERAND (t, 1);
8772 if (BASELINK_P (member))
8773 member = tsubst_baselink (member,
8774 non_reference (TREE_TYPE (object)),
8775 args, complain, in_decl);
8777 member = tsubst_copy (member, args, complain, in_decl);
8779 if (member == error_mark_node)
8780 return error_mark_node;
8781 else if (!CLASS_TYPE_P (TREE_TYPE (object)))
8783 if (TREE_CODE (member) == BIT_NOT_EXPR)
8784 return finish_pseudo_destructor_expr (object,
8786 TREE_TYPE (object));
8787 else if (TREE_CODE (member) == SCOPE_REF
8788 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
8789 return finish_pseudo_destructor_expr (object,
8791 TREE_TYPE (object));
8793 else if (TREE_CODE (member) == SCOPE_REF
8794 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
8799 /* Lookup the template functions now that we know what the
8801 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
8802 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
8803 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
8804 /*is_type_p=*/false,
8805 /*complain=*/false);
8806 if (BASELINK_P (member))
8808 BASELINK_FUNCTIONS (member)
8809 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
8811 member = (adjust_result_of_qualified_name_lookup
8812 (member, BINFO_TYPE (BASELINK_BINFO (member)),
8813 TREE_TYPE (object)));
8817 qualified_name_lookup_error (TREE_TYPE (object), tmpl,
8819 return error_mark_node;
8822 else if (TREE_CODE (member) == SCOPE_REF
8823 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
8824 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
8826 if (complain & tf_error)
8828 if (TYPE_P (TREE_OPERAND (member, 0)))
8829 error ("%qT is not a class or namespace",
8830 TREE_OPERAND (member, 0));
8832 error ("%qD is not a class or namespace",
8833 TREE_OPERAND (member, 0));
8835 return error_mark_node;
8837 else if (TREE_CODE (member) == FIELD_DECL)
8838 return finish_non_static_data_member (member, object, NULL_TREE);
8840 return finish_class_member_access_expr (object, member);
8845 (RECUR (TREE_OPERAND (t, 0)));
8849 VEC(constructor_elt,gc) *n;
8850 constructor_elt *ce;
8851 unsigned HOST_WIDE_INT idx;
8853 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8854 bool process_index_p;
8856 /* digest_init will do the wrong thing if we let it. */
8857 if (type && TYPE_PTRMEMFUNC_P (type))
8860 /* We do not want to process the index of aggregate
8861 initializers as they are identifier nodes which will be
8862 looked up by digest_init. */
8863 process_index_p = !(type && IS_AGGR_TYPE (type));
8865 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
8866 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
8868 if (ce->index && process_index_p)
8869 ce->index = RECUR (ce->index);
8870 ce->value = RECUR (ce->value);
8873 r = build_constructor (NULL_TREE, n);
8874 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
8877 return digest_init (type, r);
8883 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
8884 if (TYPE_P (operand_0))
8885 return get_typeid (operand_0);
8886 return build_typeid (operand_0);
8896 tree r = tsubst_copy (t, args, complain, in_decl);
8898 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
8899 /* If the original type was a reference, we'll be wrapped in
8900 the appropriate INDIRECT_REF. */
8901 r = convert_from_reference (r);
8906 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
8907 tsubst_copy (TREE_TYPE (t), args, complain,
8911 return fold_offsetof (RECUR (TREE_OPERAND (t, 0)));
8915 tree old_stmt_expr = cur_stmt_expr;
8916 tree stmt_expr = begin_stmt_expr ();
8918 cur_stmt_expr = stmt_expr;
8919 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl);
8920 stmt_expr = finish_stmt_expr (stmt_expr, false);
8921 cur_stmt_expr = old_stmt_expr;
8927 t = tsubst_copy (t, args, complain, in_decl);
8928 /* As in finish_id_expression, we resolve enumeration constants
8929 to their underlying values. */
8930 if (TREE_CODE (t) == CONST_DECL)
8931 return DECL_INITIAL (t);
8935 /* Handle Objective-C++ constructs, if appropriate. */
8938 = objcp_tsubst_copy_and_build (t, args, complain,
8939 in_decl, /*function_p=*/false);
8943 return tsubst_copy (t, args, complain, in_decl);
8949 /* Verify that the instantiated ARGS are valid. For type arguments,
8950 make sure that the type's linkage is ok. For non-type arguments,
8951 make sure they are constants if they are integral or enumerations.
8952 Emit an error under control of COMPLAIN, and return TRUE on error. */
8955 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
8957 int ix, len = DECL_NTPARMS (tmpl);
8958 bool result = false;
8959 bool error_p = complain & tf_error;
8961 for (ix = 0; ix != len; ix++)
8963 tree t = TREE_VEC_ELT (args, ix);
8967 /* [basic.link]: A name with no linkage (notably, the name
8968 of a class or enumeration declared in a local scope)
8969 shall not be used to declare an entity with linkage.
8970 This implies that names with no linkage cannot be used as
8971 template arguments. */
8972 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
8976 if (TYPE_ANONYMOUS_P (nt))
8977 error ("%qT is/uses anonymous type", t);
8979 error ("%qT uses local type %qT", t, nt);
8983 /* In order to avoid all sorts of complications, we do not
8984 allow variably-modified types as template arguments. */
8985 else if (variably_modified_type_p (t, NULL_TREE))
8987 if (complain & tf_error)
8988 error ("%qT is a variably modified type", t);
8992 /* A non-type argument of integral or enumerated type must be a
8994 else if (TREE_TYPE (t)
8995 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
8996 && !TREE_CONSTANT (t))
8998 if (complain & tf_error)
8999 error ("integral expression %qE is not constant", t);
9003 if (result && error_p)
9004 error (" trying to instantiate %qD", tmpl);
9008 /* Instantiate the indicated variable or function template TMPL with
9009 the template arguments in TARG_PTR. */
9012 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
9018 if (tmpl == error_mark_node)
9019 return error_mark_node;
9021 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
9023 /* If this function is a clone, handle it specially. */
9024 if (DECL_CLONED_FUNCTION_P (tmpl))
9029 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
9031 if (spec == error_mark_node)
9032 return error_mark_node;
9034 /* Look for the clone. */
9035 FOR_EACH_CLONE (clone, spec)
9036 if (DECL_NAME (clone) == DECL_NAME (tmpl))
9038 /* We should always have found the clone by now. */
9043 /* Check to see if we already have this specialization. */
9044 spec = retrieve_specialization (tmpl, targ_ptr,
9045 /*class_specializations_p=*/false);
9046 if (spec != NULL_TREE)
9049 gen_tmpl = most_general_template (tmpl);
9050 if (tmpl != gen_tmpl)
9052 /* The TMPL is a partial instantiation. To get a full set of
9053 arguments we must add the arguments used to perform the
9054 partial instantiation. */
9055 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
9058 /* Check to see if we already have this specialization. */
9059 spec = retrieve_specialization (gen_tmpl, targ_ptr,
9060 /*class_specializations_p=*/false);
9061 if (spec != NULL_TREE)
9065 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
9067 return error_mark_node;
9069 /* We are building a FUNCTION_DECL, during which the access of its
9070 parameters and return types have to be checked. However this
9071 FUNCTION_DECL which is the desired context for access checking
9072 is not built yet. We solve this chicken-and-egg problem by
9073 deferring all checks until we have the FUNCTION_DECL. */
9074 push_deferring_access_checks (dk_deferred);
9076 /* Substitute template parameters. */
9077 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
9078 targ_ptr, complain, gen_tmpl);
9080 /* Now we know the specialization, compute access previously
9082 push_access_scope (fndecl);
9083 perform_deferred_access_checks ();
9084 pop_access_scope (fndecl);
9085 pop_deferring_access_checks ();
9087 /* The DECL_TI_TEMPLATE should always be the immediate parent
9088 template, not the most general template. */
9089 DECL_TI_TEMPLATE (fndecl) = tmpl;
9091 /* If we've just instantiated the main entry point for a function,
9092 instantiate all the alternate entry points as well. We do this
9093 by cloning the instantiation of the main entry point, not by
9094 instantiating the template clones. */
9095 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
9096 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
9101 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
9102 arguments that are being used when calling it. TARGS is a vector
9103 into which the deduced template arguments are placed.
9105 Return zero for success, 2 for an incomplete match that doesn't resolve
9106 all the types, and 1 for complete failure. An error message will be
9107 printed only for an incomplete match.
9109 If FN is a conversion operator, or we are trying to produce a specific
9110 specialization, RETURN_TYPE is the return type desired.
9112 The EXPLICIT_TARGS are explicit template arguments provided via a
9115 The parameter STRICT is one of:
9118 We are deducing arguments for a function call, as in
9122 We are deducing arguments for a conversion function, as in
9126 We are deducing arguments when doing an explicit instantiation
9127 as in [temp.explicit], when determining an explicit specialization
9128 as in [temp.expl.spec], or when taking the address of a function
9129 template, as in [temp.deduct.funcaddr]. */
9132 fn_type_unification (tree fn,
9133 tree explicit_targs,
9137 unification_kind_t strict,
9144 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
9146 fntype = TREE_TYPE (fn);
9151 The specified template arguments must match the template
9152 parameters in kind (i.e., type, nontype, template), and there
9153 must not be more arguments than there are parameters;
9154 otherwise type deduction fails.
9156 Nontype arguments must match the types of the corresponding
9157 nontype template parameters, or must be convertible to the
9158 types of the corresponding nontype parameters as specified in
9159 _temp.arg.nontype_, otherwise type deduction fails.
9161 All references in the function type of the function template
9162 to the corresponding template parameters are replaced by the
9163 specified template argument values. If a substitution in a
9164 template parameter or in the function type of the function
9165 template results in an invalid type, type deduction fails. */
9167 tree converted_args;
9170 if (explicit_targs == error_mark_node)
9174 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9175 explicit_targs, NULL_TREE, tf_none,
9176 /*require_all_arguments=*/0));
9177 if (converted_args == error_mark_node)
9180 /* Substitute the explicit args into the function type. This is
9181 necessary so that, for instance, explicitly declared function
9182 arguments can match null pointed constants. If we were given
9183 an incomplete set of explicit args, we must not do semantic
9184 processing during substitution as we could create partial
9186 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
9187 processing_template_decl += incomplete;
9188 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
9189 processing_template_decl -= incomplete;
9191 if (fntype == error_mark_node)
9194 /* Place the explicitly specified arguments in TARGS. */
9195 for (i = NUM_TMPL_ARGS (converted_args); i--;)
9196 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
9199 parms = TYPE_ARG_TYPES (fntype);
9200 /* Never do unification on the 'this' parameter. */
9201 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
9202 parms = TREE_CHAIN (parms);
9206 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
9207 args = tree_cons (NULL_TREE, return_type, args);
9210 /* We allow incomplete unification without an error message here
9211 because the standard doesn't seem to explicitly prohibit it. Our
9212 callers must be ready to deal with unification failures in any
9214 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9215 targs, parms, args, /*subr=*/0,
9219 /* All is well so far. Now, check:
9223 When all template arguments have been deduced, all uses of
9224 template parameters in nondeduced contexts are replaced with
9225 the corresponding deduced argument values. If the
9226 substitution results in an invalid type, as described above,
9227 type deduction fails. */
9228 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
9235 /* Adjust types before performing type deduction, as described in
9236 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
9237 sections are symmetric. PARM is the type of a function parameter
9238 or the return type of the conversion function. ARG is the type of
9239 the argument passed to the call, or the type of the value
9240 initialized with the result of the conversion function. */
9243 maybe_adjust_types_for_deduction (unification_kind_t strict,
9256 /* Swap PARM and ARG throughout the remainder of this
9257 function; the handling is precisely symmetric since PARM
9258 will initialize ARG rather than vice versa. */
9266 /* There is nothing to do in this case. */
9273 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9275 /* [temp.deduct.call]
9277 If P is not a reference type:
9279 --If A is an array type, the pointer type produced by the
9280 array-to-pointer standard conversion (_conv.array_) is
9281 used in place of A for type deduction; otherwise,
9283 --If A is a function type, the pointer type produced by
9284 the function-to-pointer standard conversion
9285 (_conv.func_) is used in place of A for type deduction;
9288 --If A is a cv-qualified type, the top level
9289 cv-qualifiers of A's type are ignored for type
9291 if (TREE_CODE (*arg) == ARRAY_TYPE)
9292 *arg = build_pointer_type (TREE_TYPE (*arg));
9293 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9294 *arg = build_pointer_type (*arg);
9296 *arg = TYPE_MAIN_VARIANT (*arg);
9299 /* [temp.deduct.call]
9301 If P is a cv-qualified type, the top level cv-qualifiers
9302 of P's type are ignored for type deduction. If P is a
9303 reference type, the type referred to by P is used for
9305 *parm = TYPE_MAIN_VARIANT (*parm);
9306 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9308 *parm = TREE_TYPE (*parm);
9309 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9312 /* DR 322. For conversion deduction, remove a reference type on parm
9313 too (which has been swapped into ARG). */
9314 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9315 *arg = TREE_TYPE (*arg);
9320 /* Most parms like fn_type_unification.
9322 If SUBR is 1, we're being called recursively (to unify the
9323 arguments of a function or method parameter of a function
9327 type_unification_real (tree tparms,
9332 unification_kind_t strict,
9337 int ntparms = TREE_VEC_LENGTH (tparms);
9339 int saw_undeduced = 0;
9342 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
9343 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
9344 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
9345 gcc_assert (ntparms > 0);
9350 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9351 | UNIFY_ALLOW_DERIVED);
9355 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9359 sub_strict = UNIFY_ALLOW_NONE;
9370 while (parms && parms != void_list_node
9371 && args && args != void_list_node)
9373 parm = TREE_VALUE (parms);
9374 parms = TREE_CHAIN (parms);
9375 arg = TREE_VALUE (args);
9376 args = TREE_CHAIN (args);
9378 if (arg == error_mark_node)
9380 if (arg == unknown_type_node)
9381 /* We can't deduce anything from this, but we might get all the
9382 template args from other function args. */
9385 /* Conversions will be performed on a function argument that
9386 corresponds with a function parameter that contains only
9387 non-deducible template parameters and explicitly specified
9388 template parameters. */
9389 if (!uses_template_parms (parm))
9394 type = TREE_TYPE (arg);
9398 if (same_type_p (parm, type))
9400 if (strict != DEDUCE_EXACT
9401 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
9410 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
9411 if (type_unknown_p (arg))
9413 /* [temp.deduct.type] A template-argument can be deduced from
9414 a pointer to function or pointer to member function
9415 argument if the set of overloaded functions does not
9416 contain function templates and at most one of a set of
9417 overloaded functions provides a unique match. */
9419 if (resolve_overloaded_unification
9420 (tparms, targs, parm, arg, strict, sub_strict)
9425 arg = TREE_TYPE (arg);
9426 if (arg == error_mark_node)
9431 int arg_strict = sub_strict;
9434 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9436 if (unify (tparms, targs, parm, arg, arg_strict))
9441 /* Fail if we've reached the end of the parm list, and more args
9442 are present, and the parm list isn't variadic. */
9443 if (args && args != void_list_node && parms == void_list_node)
9445 /* Fail if parms are left and they don't have default values. */
9446 if (parms && parms != void_list_node
9447 && TREE_PURPOSE (parms) == NULL_TREE)
9451 for (i = 0; i < ntparms; i++)
9452 if (!TREE_VEC_ELT (targs, i))
9454 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
9456 /* If this is an undeduced nontype parameter that depends on
9457 a type parameter, try another pass; its type may have been
9458 deduced from a later argument than the one from which
9459 this parameter can be deduced. */
9460 if (TREE_CODE (tparm) == PARM_DECL
9461 && uses_template_parms (TREE_TYPE (tparm))
9462 && !saw_undeduced++)
9471 /* Subroutine of type_unification_real. Args are like the variables at the
9472 call site. ARG is an overloaded function (or template-id); we try
9473 deducing template args from each of the overloads, and if only one
9474 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
9477 resolve_overloaded_unification (tree tparms,
9481 unification_kind_t strict,
9484 tree tempargs = copy_node (targs);
9488 if (TREE_CODE (arg) == ADDR_EXPR)
9490 arg = TREE_OPERAND (arg, 0);
9496 if (TREE_CODE (arg) == COMPONENT_REF)
9497 /* Handle `&x' where `x' is some static or non-static member
9499 arg = TREE_OPERAND (arg, 1);
9501 if (TREE_CODE (arg) == OFFSET_REF)
9502 arg = TREE_OPERAND (arg, 1);
9504 /* Strip baselink information. */
9505 if (BASELINK_P (arg))
9506 arg = BASELINK_FUNCTIONS (arg);
9508 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
9510 /* If we got some explicit template args, we need to plug them into
9511 the affected templates before we try to unify, in case the
9512 explicit args will completely resolve the templates in question. */
9514 tree expl_subargs = TREE_OPERAND (arg, 1);
9515 arg = TREE_OPERAND (arg, 0);
9517 for (; arg; arg = OVL_NEXT (arg))
9519 tree fn = OVL_CURRENT (arg);
9522 if (TREE_CODE (fn) != TEMPLATE_DECL)
9525 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
9526 expl_subargs, /*check_ret=*/false);
9529 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
9530 good += try_one_overload (tparms, targs, tempargs, parm,
9531 elem, strict, sub_strict, addr_p);
9537 gcc_assert (TREE_CODE (arg) == OVERLOAD
9538 || TREE_CODE (arg) == FUNCTION_DECL);
9540 for (; arg; arg = OVL_NEXT (arg))
9541 good += try_one_overload (tparms, targs, tempargs, parm,
9542 TREE_TYPE (OVL_CURRENT (arg)),
9543 strict, sub_strict, addr_p);
9546 /* [temp.deduct.type] A template-argument can be deduced from a pointer
9547 to function or pointer to member function argument if the set of
9548 overloaded functions does not contain function templates and at most
9549 one of a set of overloaded functions provides a unique match.
9551 So if we found multiple possibilities, we return success but don't
9556 int i = TREE_VEC_LENGTH (targs);
9558 if (TREE_VEC_ELT (tempargs, i))
9559 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
9567 /* Subroutine of resolve_overloaded_unification; does deduction for a single
9568 overload. Fills TARGS with any deduced arguments, or error_mark_node if
9569 different overloads deduce different arguments for a given parm.
9570 ADDR_P is true if the expression for which deduction is being
9571 performed was of the form "& fn" rather than simply "fn".
9573 Returns 1 on success. */
9576 try_one_overload (tree tparms,
9581 unification_kind_t strict,
9589 /* [temp.deduct.type] A template-argument can be deduced from a pointer
9590 to function or pointer to member function argument if the set of
9591 overloaded functions does not contain function templates and at most
9592 one of a set of overloaded functions provides a unique match.
9594 So if this is a template, just return success. */
9596 if (uses_template_parms (arg))
9599 if (TREE_CODE (arg) == METHOD_TYPE)
9600 arg = build_ptrmemfunc_type (build_pointer_type (arg));
9602 arg = build_pointer_type (arg);
9604 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9606 /* We don't copy orig_targs for this because if we have already deduced
9607 some template args from previous args, unify would complain when we
9608 try to deduce a template parameter for the same argument, even though
9609 there isn't really a conflict. */
9610 nargs = TREE_VEC_LENGTH (targs);
9611 tempargs = make_tree_vec (nargs);
9613 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
9616 /* First make sure we didn't deduce anything that conflicts with
9617 explicitly specified args. */
9618 for (i = nargs; i--; )
9620 tree elt = TREE_VEC_ELT (tempargs, i);
9621 tree oldelt = TREE_VEC_ELT (orig_targs, i);
9625 else if (uses_template_parms (elt))
9626 /* Since we're unifying against ourselves, we will fill in
9627 template args used in the function parm list with our own
9628 template parms. Discard them. */
9629 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
9630 else if (oldelt && !template_args_equal (oldelt, elt))
9634 for (i = nargs; i--; )
9636 tree elt = TREE_VEC_ELT (tempargs, i);
9639 TREE_VEC_ELT (targs, i) = elt;
9645 /* Verify that nondeduce template argument agrees with the type
9646 obtained from argument deduction. Return nonzero if the
9651 struct A { typedef int X; };
9652 template <class T, class U> struct C {};
9653 template <class T> struct C<T, typename T::X> {};
9655 Then with the instantiation `C<A, int>', we can deduce that
9656 `T' is `A' but unify () does not check whether `typename T::X'
9657 is `int'. This function ensure that they agree.
9659 TARGS, PARMS are the same as the arguments of unify.
9660 ARGS contains template arguments from all levels. */
9663 verify_class_unification (tree targs, tree parms, tree args)
9665 parms = tsubst (parms, add_outermost_template_args (args, targs),
9666 tf_none, NULL_TREE);
9667 if (parms == error_mark_node)
9670 return !comp_template_args (parms, INNERMOST_TEMPLATE_ARGS (args));
9673 /* PARM is a template class (perhaps with unbound template
9674 parameters). ARG is a fully instantiated type. If ARG can be
9675 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
9676 TARGS are as for unify. */
9679 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
9683 if (!CLASSTYPE_TEMPLATE_INFO (arg)
9684 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
9685 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
9688 /* We need to make a new template argument vector for the call to
9689 unify. If we used TARGS, we'd clutter it up with the result of
9690 the attempted unification, even if this class didn't work out.
9691 We also don't want to commit ourselves to all the unifications
9692 we've already done, since unification is supposed to be done on
9693 an argument-by-argument basis. In other words, consider the
9694 following pathological case:
9696 template <int I, int J, int K>
9699 template <int I, int J>
9700 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
9702 template <int I, int J, int K>
9703 void f(S<I, J, K>, S<I, I, I>);
9712 Now, by the time we consider the unification involving `s2', we
9713 already know that we must have `f<0, 0, 0>'. But, even though
9714 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
9715 because there are two ways to unify base classes of S<0, 1, 2>
9716 with S<I, I, I>. If we kept the already deduced knowledge, we
9717 would reject the possibility I=1. */
9718 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
9720 /* If unification failed, we're done. */
9721 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
9722 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
9728 /* Given a template type PARM and a class type ARG, find the unique
9729 base type in ARG that is an instance of PARM. We do not examine
9730 ARG itself; only its base-classes. If there is not exactly one
9731 appropriate base class, return NULL_TREE. PARM may be the type of
9732 a partial specialization, as well as a plain template type. Used
9736 get_template_base (tree tparms, tree targs, tree parm, tree arg)
9738 tree rval = NULL_TREE;
9741 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
9743 binfo = TYPE_BINFO (complete_type (arg));
9745 /* The type could not be completed. */
9748 /* Walk in inheritance graph order. The search order is not
9749 important, and this avoids multiple walks of virtual bases. */
9750 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
9752 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
9756 /* If there is more than one satisfactory baseclass, then:
9760 If they yield more than one possible deduced A, the type
9764 if (rval && !same_type_p (r, rval))
9774 /* Returns the level of DECL, which declares a template parameter. */
9777 template_decl_level (tree decl)
9779 switch (TREE_CODE (decl))
9783 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
9786 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
9794 /* Decide whether ARG can be unified with PARM, considering only the
9795 cv-qualifiers of each type, given STRICT as documented for unify.
9796 Returns nonzero iff the unification is OK on that basis. */
9799 check_cv_quals_for_unify (int strict, tree arg, tree parm)
9801 int arg_quals = cp_type_quals (arg);
9802 int parm_quals = cp_type_quals (parm);
9804 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
9805 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
9807 /* Although a CVR qualifier is ignored when being applied to a
9808 substituted template parameter ([8.3.2]/1 for example), that
9809 does not apply during deduction [14.8.2.4]/1, (even though
9810 that is not explicitly mentioned, [14.8.2.4]/9 indicates
9811 this). Except when we're allowing additional CV qualifiers
9812 at the outer level [14.8.2.1]/3,1st bullet. */
9813 if ((TREE_CODE (arg) == REFERENCE_TYPE
9814 || TREE_CODE (arg) == FUNCTION_TYPE
9815 || TREE_CODE (arg) == METHOD_TYPE)
9816 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
9819 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
9820 && (parm_quals & TYPE_QUAL_RESTRICT))
9824 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
9825 && (arg_quals & parm_quals) != parm_quals)
9828 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
9829 && (parm_quals & arg_quals) != arg_quals)
9835 /* Takes parameters as for type_unification. Returns 0 if the
9836 type deduction succeeds, 1 otherwise. The parameter STRICT is a
9837 bitwise or of the following flags:
9840 Require an exact match between PARM and ARG.
9841 UNIFY_ALLOW_MORE_CV_QUAL:
9842 Allow the deduced ARG to be more cv-qualified (by qualification
9843 conversion) than ARG.
9844 UNIFY_ALLOW_LESS_CV_QUAL:
9845 Allow the deduced ARG to be less cv-qualified than ARG.
9846 UNIFY_ALLOW_DERIVED:
9847 Allow the deduced ARG to be a template base class of ARG,
9848 or a pointer to a template base class of the type pointed to by
9850 UNIFY_ALLOW_INTEGER:
9851 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
9852 case for more information.
9853 UNIFY_ALLOW_OUTER_LEVEL:
9854 This is the outermost level of a deduction. Used to determine validity
9855 of qualification conversions. A valid qualification conversion must
9856 have const qualified pointers leading up to the inner type which
9857 requires additional CV quals, except at the outer level, where const
9858 is not required [conv.qual]. It would be normal to set this flag in
9859 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
9860 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
9861 This is the outermost level of a deduction, and PARM can be more CV
9862 qualified at this point.
9863 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
9864 This is the outermost level of a deduction, and PARM can be less CV
9865 qualified at this point. */
9868 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
9873 int strict_in = strict;
9875 /* I don't think this will do the right thing with respect to types.
9876 But the only case I've seen it in so far has been array bounds, where
9877 signedness is the only information lost, and I think that will be
9879 while (TREE_CODE (parm) == NOP_EXPR)
9880 parm = TREE_OPERAND (parm, 0);
9882 if (arg == error_mark_node)
9884 if (arg == unknown_type_node)
9885 /* We can't deduce anything from this, but we might get all the
9886 template args from other function args. */
9889 /* If PARM uses template parameters, then we can't bail out here,
9890 even if ARG == PARM, since we won't record unifications for the
9891 template parameters. We might need them if we're trying to
9892 figure out which of two things is more specialized. */
9893 if (arg == parm && !uses_template_parms (parm))
9896 /* Immediately reject some pairs that won't unify because of
9897 cv-qualification mismatches. */
9898 if (TREE_CODE (arg) == TREE_CODE (parm)
9900 /* It is the elements of the array which hold the cv quals of an array
9901 type, and the elements might be template type parms. We'll check
9903 && TREE_CODE (arg) != ARRAY_TYPE
9904 /* We check the cv-qualifiers when unifying with template type
9905 parameters below. We want to allow ARG `const T' to unify with
9906 PARM `T' for example, when computing which of two templates
9907 is more specialized, for example. */
9908 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
9909 && !check_cv_quals_for_unify (strict_in, arg, parm))
9912 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
9913 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
9914 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
9915 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
9916 strict &= ~UNIFY_ALLOW_DERIVED;
9917 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9918 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
9920 switch (TREE_CODE (parm))
9924 case UNBOUND_CLASS_TEMPLATE:
9925 /* In a type which contains a nested-name-specifier, template
9926 argument values cannot be deduced for template parameters used
9927 within the nested-name-specifier. */
9930 case TEMPLATE_TYPE_PARM:
9931 case TEMPLATE_TEMPLATE_PARM:
9932 case BOUND_TEMPLATE_TEMPLATE_PARM:
9933 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
9935 if (TEMPLATE_TYPE_LEVEL (parm)
9936 != template_decl_level (tparm))
9937 /* The PARM is not one we're trying to unify. Just check
9938 to see if it matches ARG. */
9939 return (TREE_CODE (arg) == TREE_CODE (parm)
9940 && same_type_p (parm, arg)) ? 0 : 1;
9941 idx = TEMPLATE_TYPE_IDX (parm);
9942 targ = TREE_VEC_ELT (targs, idx);
9943 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
9945 /* Check for mixed types and values. */
9946 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
9947 && TREE_CODE (tparm) != TYPE_DECL)
9948 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
9949 && TREE_CODE (tparm) != TEMPLATE_DECL))
9952 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
9954 /* ARG must be constructed from a template class or a template
9955 template parameter. */
9956 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
9957 && (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg)))
9961 tree parmtmpl = TYPE_TI_TEMPLATE (parm);
9962 tree parmvec = TYPE_TI_ARGS (parm);
9963 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
9965 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
9968 /* The parameter and argument roles have to be switched here
9969 in order to handle default arguments properly. For example,
9970 template<template <class> class TT> void f(TT<int>)
9971 should be able to accept vector<int> which comes from
9972 template <class T, class Allocator = allocator>
9975 if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1)
9979 /* Deduce arguments T, i from TT<T> or TT<i>.
9980 We check each element of PARMVEC and ARGVEC individually
9981 rather than the whole TREE_VEC since they can have
9982 different number of elements. */
9984 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
9986 if (unify (tparms, targs,
9987 TREE_VEC_ELT (parmvec, i),
9988 TREE_VEC_ELT (argvec, i),
9993 arg = TYPE_TI_TEMPLATE (arg);
9995 /* Fall through to deduce template name. */
9998 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
9999 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10001 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
10003 /* Simple cases: Value already set, does match or doesn't. */
10004 if (targ != NULL_TREE && template_args_equal (targ, arg))
10011 /* If PARM is `const T' and ARG is only `int', we don't have
10012 a match unless we are allowing additional qualification.
10013 If ARG is `const int' and PARM is just `T' that's OK;
10014 that binds `const int' to `T'. */
10015 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
10019 /* Consider the case where ARG is `const volatile int' and
10020 PARM is `const T'. Then, T should be `volatile int'. */
10021 arg = cp_build_qualified_type_real
10022 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
10023 if (arg == error_mark_node)
10026 /* Simple cases: Value already set, does match or doesn't. */
10027 if (targ != NULL_TREE && same_type_p (targ, arg))
10032 /* Make sure that ARG is not a variable-sized array. (Note
10033 that were talking about variable-sized arrays (like
10034 `int[n]'), rather than arrays of unknown size (like
10035 `int[]').) We'll get very confused by such a type since
10036 the bound of the array will not be computable in an
10037 instantiation. Besides, such types are not allowed in
10038 ISO C++, so we can do as we please here. */
10039 if (variably_modified_type_p (arg, NULL_TREE))
10043 TREE_VEC_ELT (targs, idx) = arg;
10046 case TEMPLATE_PARM_INDEX:
10047 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10049 if (TEMPLATE_PARM_LEVEL (parm)
10050 != template_decl_level (tparm))
10051 /* The PARM is not one we're trying to unify. Just check
10052 to see if it matches ARG. */
10053 return !(TREE_CODE (arg) == TREE_CODE (parm)
10054 && cp_tree_equal (parm, arg));
10056 idx = TEMPLATE_PARM_IDX (parm);
10057 targ = TREE_VEC_ELT (targs, idx);
10060 return !cp_tree_equal (targ, arg);
10062 /* [temp.deduct.type] If, in the declaration of a function template
10063 with a non-type template-parameter, the non-type
10064 template-parameter is used in an expression in the function
10065 parameter-list and, if the corresponding template-argument is
10066 deduced, the template-argument type shall match the type of the
10067 template-parameter exactly, except that a template-argument
10068 deduced from an array bound may be of any integral type.
10069 The non-type parameter might use already deduced type parameters. */
10070 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
10071 if (!TREE_TYPE (arg))
10072 /* Template-parameter dependent expression. Just accept it for now.
10073 It will later be processed in convert_template_argument. */
10075 else if (same_type_p (TREE_TYPE (arg), tparm))
10077 else if ((strict & UNIFY_ALLOW_INTEGER)
10078 && (TREE_CODE (tparm) == INTEGER_TYPE
10079 || TREE_CODE (tparm) == BOOLEAN_TYPE))
10080 /* Convert the ARG to the type of PARM; the deduced non-type
10081 template argument must exactly match the types of the
10082 corresponding parameter. */
10083 arg = fold (build_nop (TREE_TYPE (parm), arg));
10084 else if (uses_template_parms (tparm))
10085 /* We haven't deduced the type of this parameter yet. Try again
10091 TREE_VEC_ELT (targs, idx) = arg;
10096 /* A pointer-to-member constant can be unified only with
10097 another constant. */
10098 if (TREE_CODE (arg) != PTRMEM_CST)
10101 /* Just unify the class member. It would be useless (and possibly
10102 wrong, depending on the strict flags) to unify also
10103 PTRMEM_CST_CLASS, because we want to be sure that both parm and
10104 arg refer to the same variable, even if through different
10105 classes. For instance:
10107 struct A { int x; };
10110 Unification of &A::x and &B::x must succeed. */
10111 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
10112 PTRMEM_CST_MEMBER (arg), strict);
10117 if (TREE_CODE (arg) != POINTER_TYPE)
10120 /* [temp.deduct.call]
10122 A can be another pointer or pointer to member type that can
10123 be converted to the deduced A via a qualification
10124 conversion (_conv.qual_).
10126 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
10127 This will allow for additional cv-qualification of the
10128 pointed-to types if appropriate. */
10130 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10131 /* The derived-to-base conversion only persists through one
10132 level of pointers. */
10133 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10135 return unify (tparms, targs, TREE_TYPE (parm),
10136 TREE_TYPE (arg), strict);
10139 case REFERENCE_TYPE:
10140 if (TREE_CODE (arg) != REFERENCE_TYPE)
10142 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10143 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10146 if (TREE_CODE (arg) != ARRAY_TYPE)
10148 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10149 != (TYPE_DOMAIN (arg) == NULL_TREE))
10151 if (TYPE_DOMAIN (parm) != NULL_TREE)
10156 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
10157 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
10159 /* Our representation of array types uses "N - 1" as the
10160 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
10161 not an integer constant. */
10162 if (TREE_CODE (parm_max) == MINUS_EXPR)
10164 arg_max = fold_build2 (PLUS_EXPR,
10167 TREE_OPERAND (parm_max, 1));
10168 parm_max = TREE_OPERAND (parm_max, 0);
10171 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
10174 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10175 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10182 case ENUMERAL_TYPE:
10184 if (TREE_CODE (arg) != TREE_CODE (parm))
10187 /* We have already checked cv-qualification at the top of the
10189 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10192 /* As far as unification is concerned, this wins. Later checks
10193 will invalidate it if necessary. */
10196 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10197 /* Type INTEGER_CST can come from ordinary constant template args. */
10199 while (TREE_CODE (arg) == NOP_EXPR)
10200 arg = TREE_OPERAND (arg, 0);
10202 if (TREE_CODE (arg) != INTEGER_CST)
10204 return !tree_int_cst_equal (parm, arg);
10209 if (TREE_CODE (arg) != TREE_VEC)
10211 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10213 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10214 if (unify (tparms, targs,
10215 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10223 if (TREE_CODE (arg) != TREE_CODE (parm))
10226 if (TYPE_PTRMEMFUNC_P (parm))
10228 if (!TYPE_PTRMEMFUNC_P (arg))
10231 return unify (tparms, targs,
10232 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10233 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10237 if (CLASSTYPE_TEMPLATE_INFO (parm))
10239 tree t = NULL_TREE;
10241 if (strict_in & UNIFY_ALLOW_DERIVED)
10243 /* First, we try to unify the PARM and ARG directly. */
10244 t = try_class_unification (tparms, targs,
10249 /* Fallback to the special case allowed in
10250 [temp.deduct.call]:
10252 If P is a class, and P has the form
10253 template-id, then A can be a derived class of
10254 the deduced A. Likewise, if P is a pointer to
10255 a class of the form template-id, A can be a
10256 pointer to a derived class pointed to by the
10258 t = get_template_base (tparms, targs, parm, arg);
10264 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10265 && (CLASSTYPE_TI_TEMPLATE (parm)
10266 == CLASSTYPE_TI_TEMPLATE (arg)))
10267 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10268 Then, we should unify `int' and `U'. */
10271 /* There's no chance of unification succeeding. */
10274 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10275 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10277 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10282 case FUNCTION_TYPE:
10283 if (TREE_CODE (arg) != TREE_CODE (parm))
10286 /* CV qualifications for methods can never be deduced, they must
10287 match exactly. We need to check them explicitly here,
10288 because type_unification_real treats them as any other
10289 cvqualified parameter. */
10290 if (TREE_CODE (parm) == METHOD_TYPE
10291 && (!check_cv_quals_for_unify
10293 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
10294 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
10297 if (unify (tparms, targs, TREE_TYPE (parm),
10298 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10300 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10301 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
10305 /* Unify a pointer to member with a pointer to member function, which
10306 deduces the type of the member as a function type. */
10307 if (TYPE_PTRMEMFUNC_P (arg))
10311 cp_cv_quals cv_quals;
10313 /* Check top-level cv qualifiers */
10314 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
10317 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10318 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
10321 /* Determine the type of the function we are unifying against. */
10322 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
10324 build_function_type (TREE_TYPE (method_type),
10325 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
10327 /* Extract the cv-qualifiers of the member function from the
10328 implicit object parameter and place them on the function
10329 type to be restored later. */
10331 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
10332 fntype = build_qualified_type (fntype, cv_quals);
10333 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
10336 if (TREE_CODE (arg) != OFFSET_TYPE)
10338 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10339 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10341 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10345 if (DECL_TEMPLATE_PARM_P (parm))
10346 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10347 if (arg != integral_constant_value (parm))
10352 case TEMPLATE_DECL:
10353 /* Matched cases are handled by the ARG == PARM test above. */
10357 gcc_assert (EXPR_P (parm));
10359 /* We must be looking at an expression. This can happen with
10363 void foo(S<I>, S<I + 2>);
10365 This is a "nondeduced context":
10369 The nondeduced contexts are:
10371 --A type that is a template-id in which one or more of
10372 the template-arguments is an expression that references
10373 a template-parameter.
10375 In these cases, we assume deduction succeeded, but don't
10376 actually infer any unifications. */
10378 if (!uses_template_parms (parm)
10379 && !template_args_equal (parm, arg))
10386 /* Note that DECL can be defined in this translation unit, if
10390 mark_definable (tree decl)
10393 DECL_NOT_REALLY_EXTERN (decl) = 1;
10394 FOR_EACH_CLONE (clone, decl)
10395 DECL_NOT_REALLY_EXTERN (clone) = 1;
10398 /* Called if RESULT is explicitly instantiated, or is a member of an
10399 explicitly instantiated class. */
10402 mark_decl_instantiated (tree result, int extern_p)
10404 SET_DECL_EXPLICIT_INSTANTIATION (result);
10406 /* If this entity has already been written out, it's too late to
10407 make any modifications. */
10408 if (TREE_ASM_WRITTEN (result))
10411 if (TREE_CODE (result) != FUNCTION_DECL)
10412 /* The TREE_PUBLIC flag for function declarations will have been
10413 set correctly by tsubst. */
10414 TREE_PUBLIC (result) = 1;
10416 /* This might have been set by an earlier implicit instantiation. */
10417 DECL_COMDAT (result) = 0;
10420 DECL_NOT_REALLY_EXTERN (result) = 0;
10423 mark_definable (result);
10424 /* Always make artificials weak. */
10425 if (DECL_ARTIFICIAL (result) && flag_weak)
10426 comdat_linkage (result);
10427 /* For WIN32 we also want to put explicit instantiations in
10428 linkonce sections. */
10429 else if (TREE_PUBLIC (result))
10430 maybe_make_one_only (result);
10433 /* If EXTERN_P, then this function will not be emitted -- unless
10434 followed by an explicit instantiation, at which point its linkage
10435 will be adjusted. If !EXTERN_P, then this function will be
10436 emitted here. In neither circumstance do we want
10437 import_export_decl to adjust the linkage. */
10438 DECL_INTERFACE_KNOWN (result) = 1;
10441 /* Given two function templates PAT1 and PAT2, return:
10443 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
10444 -1 if PAT2 is more specialized than PAT1.
10445 0 if neither is more specialized.
10447 LEN indicates the number of parameters we should consider
10448 (defaulted parameters should not be considered).
10450 The 1998 std underspecified function template partial ordering, and
10451 DR214 addresses the issue. We take pairs of arguments, one from
10452 each of the templates, and deduce them against each other. One of
10453 the templates will be more specialized if all the *other*
10454 template's arguments deduce against its arguments and at least one
10455 of its arguments *does* *not* deduce against the other template's
10456 corresponding argument. Deduction is done as for class templates.
10457 The arguments used in deduction have reference and top level cv
10458 qualifiers removed. Iff both arguments were originally reference
10459 types *and* deduction succeeds in both directions, the template
10460 with the more cv-qualified argument wins for that pairing (if
10461 neither is more cv-qualified, they both are equal). Unlike regular
10462 deduction, after all the arguments have been deduced in this way,
10463 we do *not* verify the deduced template argument values can be
10464 substituted into non-deduced contexts, nor do we have to verify
10465 that all template arguments have been deduced. */
10468 more_specialized_fn (tree pat1, tree pat2, int len)
10470 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
10471 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
10472 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
10473 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
10474 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
10475 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
10476 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
10477 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
10481 /* If only one is a member function, they are unordered. */
10482 if (DECL_FUNCTION_MEMBER_P (decl1) != DECL_FUNCTION_MEMBER_P (decl2))
10485 /* Don't consider 'this' parameter. */
10486 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
10487 args1 = TREE_CHAIN (args1);
10488 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
10489 args2 = TREE_CHAIN (args2);
10491 /* If only one is a conversion operator, they are unordered. */
10492 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
10495 /* Consider the return type for a conversion function */
10496 if (DECL_CONV_FN_P (decl1))
10498 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
10499 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
10503 processing_template_decl++;
10507 tree arg1 = TREE_VALUE (args1);
10508 tree arg2 = TREE_VALUE (args2);
10509 int deduce1, deduce2;
10513 if (TREE_CODE (arg1) == REFERENCE_TYPE)
10515 arg1 = TREE_TYPE (arg1);
10516 quals1 = cp_type_quals (arg1);
10519 if (TREE_CODE (arg2) == REFERENCE_TYPE)
10521 arg2 = TREE_TYPE (arg2);
10522 quals2 = cp_type_quals (arg2);
10525 if ((quals1 < 0) != (quals2 < 0))
10527 /* Only of the args is a reference, see if we should apply
10528 array/function pointer decay to it. This is not part of
10529 DR214, but is, IMHO, consistent with the deduction rules
10530 for the function call itself, and with our earlier
10531 implementation of the underspecified partial ordering
10532 rules. (nathan). */
10535 switch (TREE_CODE (arg1))
10538 arg1 = TREE_TYPE (arg1);
10540 case FUNCTION_TYPE:
10541 arg1 = build_pointer_type (arg1);
10550 switch (TREE_CODE (arg2))
10553 arg2 = TREE_TYPE (arg2);
10555 case FUNCTION_TYPE:
10556 arg2 = build_pointer_type (arg2);
10565 arg1 = TYPE_MAIN_VARIANT (arg1);
10566 arg2 = TYPE_MAIN_VARIANT (arg2);
10568 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
10569 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
10575 if (better1 < 0 && better2 < 0)
10576 /* We've failed to deduce something in either direction.
10577 These must be unordered. */
10580 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
10582 /* Deduces in both directions, see if quals can
10583 disambiguate. Pretend the worse one failed to deduce. */
10584 if ((quals1 & quals2) == quals2)
10586 if ((quals1 & quals2) == quals1)
10589 if (deduce1 && !deduce2 && !better2)
10591 if (deduce2 && !deduce1 && !better1)
10594 args1 = TREE_CHAIN (args1);
10595 args2 = TREE_CHAIN (args2);
10598 processing_template_decl--;
10600 return (better1 > 0) - (better2 > 0);
10603 /* Given two class template specialization list nodes PAT1 and PAT2, return:
10605 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
10606 -1 if PAT2 is more specialized than PAT1.
10607 0 if neither is more specialized.
10609 FULL_ARGS is the full set of template arguments that triggers this
10610 partial ordering. */
10613 more_specialized_class (tree pat1, tree pat2, tree full_args)
10618 /* Just like what happens for functions, if we are ordering between
10619 different class template specializations, we may encounter dependent
10620 types in the arguments, and we need our dependency check functions
10621 to behave correctly. */
10622 ++processing_template_decl;
10623 targs = get_class_bindings (TREE_VALUE (pat1), TREE_PURPOSE (pat1),
10624 add_outermost_template_args (full_args, TREE_PURPOSE (pat2)));
10628 targs = get_class_bindings (TREE_VALUE (pat2), TREE_PURPOSE (pat2),
10629 add_outermost_template_args (full_args, TREE_PURPOSE (pat1)));
10632 --processing_template_decl;
10637 /* Return the template arguments that will produce the function signature
10638 DECL from the function template FN, with the explicit template
10639 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
10640 also match. Return NULL_TREE if no satisfactory arguments could be
10644 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
10646 int ntparms = DECL_NTPARMS (fn);
10647 tree targs = make_tree_vec (ntparms);
10649 tree decl_arg_types;
10651 /* Substitute the explicit template arguments into the type of DECL.
10652 The call to fn_type_unification will handle substitution into the
10654 decl_type = TREE_TYPE (decl);
10655 if (explicit_args && uses_template_parms (decl_type))
10658 tree converted_args;
10660 if (DECL_TEMPLATE_INFO (decl))
10661 tmpl = DECL_TI_TEMPLATE (decl);
10663 /* We can get here for some invalid specializations. */
10667 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
10668 explicit_args, NULL_TREE,
10669 tf_none, /*require_all_arguments=*/0));
10670 if (converted_args == error_mark_node)
10673 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
10674 if (decl_type == error_mark_node)
10678 decl_arg_types = TYPE_ARG_TYPES (decl_type);
10679 /* Never do unification on the 'this' parameter. */
10680 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
10681 decl_arg_types = TREE_CHAIN (decl_arg_types);
10683 if (fn_type_unification (fn, explicit_args, targs,
10685 (check_rettype || DECL_CONV_FN_P (fn)
10686 ? TREE_TYPE (decl_type) : NULL_TREE),
10687 DEDUCE_EXACT, LOOKUP_NORMAL))
10693 /* Return the innermost template arguments that, when applied to a
10694 template specialization whose innermost template parameters are
10695 TPARMS, and whose specialization arguments are PARMS, yield the
10698 For example, suppose we have:
10700 template <class T, class U> struct S {};
10701 template <class T> struct S<T*, int> {};
10703 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
10704 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
10705 int}. The resulting vector will be {double}, indicating that `T'
10706 is bound to `double'. */
10709 get_class_bindings (tree tparms, tree parms, tree args)
10711 int i, ntparms = TREE_VEC_LENGTH (tparms);
10712 tree vec = make_tree_vec (ntparms);
10714 if (unify (tparms, vec, parms, INNERMOST_TEMPLATE_ARGS (args),
10718 for (i = 0; i < ntparms; ++i)
10719 if (! TREE_VEC_ELT (vec, i))
10722 if (verify_class_unification (vec, parms, args))
10728 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
10729 Pick the most specialized template, and return the corresponding
10730 instantiation, or if there is no corresponding instantiation, the
10731 template itself. If there is no most specialized template,
10732 error_mark_node is returned. If there are no templates at all,
10733 NULL_TREE is returned. */
10736 most_specialized_instantiation (tree instantiations)
10740 if (!instantiations)
10743 ++processing_template_decl;
10745 champ = instantiations;
10746 for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn))
10750 if (get_bindings (TREE_VALUE (champ),
10751 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
10752 NULL_TREE, /*check_ret=*/false))
10755 if (get_bindings (TREE_VALUE (fn),
10756 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
10757 NULL_TREE, /*check_ret=*/false))
10763 /* Equally specialized, move to next function. If there
10764 is no next function, nothing's most specialized. */
10765 fn = TREE_CHAIN (fn);
10771 /* Now verify that champ is better than everything earlier in the
10772 instantiation list. */
10773 for (fn = instantiations; fn != champ; fn = TREE_CHAIN (fn))
10774 if (get_bindings (TREE_VALUE (champ),
10775 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
10776 NULL_TREE, /*check_ret=*/false)
10777 || !get_bindings (TREE_VALUE (fn),
10778 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
10779 NULL_TREE, /*check_ret=*/false))
10785 processing_template_decl--;
10788 return error_mark_node;
10790 return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ);
10793 /* Return the most specialized of the list of templates in FNS that can
10794 produce an instantiation matching DECL, given the explicit template
10795 arguments EXPLICIT_ARGS. */
10798 most_specialized (tree fns, tree decl, tree explicit_args)
10800 tree candidates = NULL_TREE;
10803 for (fn = fns; fn; fn = TREE_CHAIN (fn))
10805 tree candidate = TREE_VALUE (fn);
10807 args = get_bindings (candidate, decl, explicit_args, /*check_ret=*/true);
10809 candidates = tree_cons (NULL_TREE, candidate, candidates);
10812 return most_specialized_instantiation (candidates);
10815 /* If DECL is a specialization of some template, return the most
10816 general such template. Otherwise, returns NULL_TREE.
10818 For example, given:
10820 template <class T> struct S { template <class U> void f(U); };
10822 if TMPL is `template <class U> void S<int>::f(U)' this will return
10823 the full template. This function will not trace past partial
10824 specializations, however. For example, given in addition:
10826 template <class T> struct S<T*> { template <class U> void f(U); };
10828 if TMPL is `template <class U> void S<int*>::f(U)' this will return
10829 `template <class T> template <class U> S<T*>::f(U)'. */
10832 most_general_template (tree decl)
10834 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
10835 an immediate specialization. */
10836 if (TREE_CODE (decl) == FUNCTION_DECL)
10838 if (DECL_TEMPLATE_INFO (decl)) {
10839 decl = DECL_TI_TEMPLATE (decl);
10841 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
10842 template friend. */
10843 if (TREE_CODE (decl) != TEMPLATE_DECL)
10849 /* Look for more and more general templates. */
10850 while (DECL_TEMPLATE_INFO (decl))
10852 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
10853 (See cp-tree.h for details.) */
10854 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
10857 if (CLASS_TYPE_P (TREE_TYPE (decl))
10858 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
10861 /* Stop if we run into an explicitly specialized class template. */
10862 if (!DECL_NAMESPACE_SCOPE_P (decl)
10863 && DECL_CONTEXT (decl)
10864 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
10867 decl = DECL_TI_TEMPLATE (decl);
10873 /* Return the most specialized of the class template specializations
10874 of TMPL which can produce an instantiation matching ARGS, or
10875 error_mark_node if the choice is ambiguous. */
10878 most_specialized_class (tree tmpl, tree args)
10880 tree list = NULL_TREE;
10885 tmpl = most_general_template (tmpl);
10886 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
10889 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args);
10892 list = tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list);
10893 TREE_TYPE (list) = TREE_TYPE (t);
10902 t = TREE_CHAIN (t);
10903 for (; t; t = TREE_CHAIN (t))
10905 fate = more_specialized_class (champ, t, args);
10912 t = TREE_CHAIN (t);
10914 return error_mark_node;
10920 for (t = list; t && t != champ; t = TREE_CHAIN (t))
10922 fate = more_specialized_class (champ, t, args);
10924 return error_mark_node;
10930 /* Explicitly instantiate DECL. */
10933 do_decl_instantiation (tree decl, tree storage)
10935 tree result = NULL_TREE;
10939 /* An error occurred, for which grokdeclarator has already issued
10940 an appropriate message. */
10942 else if (! DECL_LANG_SPECIFIC (decl))
10944 error ("explicit instantiation of non-template %q#D", decl);
10947 else if (TREE_CODE (decl) == VAR_DECL)
10949 /* There is an asymmetry here in the way VAR_DECLs and
10950 FUNCTION_DECLs are handled by grokdeclarator. In the case of
10951 the latter, the DECL we get back will be marked as a
10952 template instantiation, and the appropriate
10953 DECL_TEMPLATE_INFO will be set up. This does not happen for
10954 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
10955 should handle VAR_DECLs as it currently handles
10957 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
10958 if (!result || TREE_CODE (result) != VAR_DECL)
10960 error ("no matching template for %qD found", decl);
10964 else if (TREE_CODE (decl) != FUNCTION_DECL)
10966 error ("explicit instantiation of %q#D", decl);
10972 /* Check for various error cases. Note that if the explicit
10973 instantiation is valid the RESULT will currently be marked as an
10974 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
10975 until we get here. */
10977 if (DECL_TEMPLATE_SPECIALIZATION (result))
10979 /* DR 259 [temp.spec].
10981 Both an explicit instantiation and a declaration of an explicit
10982 specialization shall not appear in a program unless the explicit
10983 instantiation follows a declaration of the explicit specialization.
10985 For a given set of template parameters, if an explicit
10986 instantiation of a template appears after a declaration of an
10987 explicit specialization for that template, the explicit
10988 instantiation has no effect. */
10991 else if (DECL_EXPLICIT_INSTANTIATION (result))
10995 No program shall explicitly instantiate any template more
10998 We check DECL_NOT_REALLY_EXTERN so as not to complain when
10999 the first instantiation was `extern' and the second is not,
11000 and EXTERN_P for the opposite case. */
11001 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
11002 pedwarn ("duplicate explicit instantiation of %q#D", result);
11003 /* If an "extern" explicit instantiation follows an ordinary
11004 explicit instantiation, the template is instantiated. */
11008 else if (!DECL_IMPLICIT_INSTANTIATION (result))
11010 error ("no matching template for %qD found", result);
11013 else if (!DECL_TEMPLATE_INFO (result))
11015 pedwarn ("explicit instantiation of non-template %q#D", result);
11019 if (storage == NULL_TREE)
11021 else if (storage == ridpointers[(int) RID_EXTERN])
11023 if (pedantic && !in_system_header)
11024 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
11029 error ("storage class %qD applied to template instantiation", storage);
11031 mark_decl_instantiated (result, extern_p);
11033 instantiate_decl (result, /*defer_ok=*/1,
11034 /*expl_inst_class_mem_p=*/false);
11038 mark_class_instantiated (tree t, int extern_p)
11040 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
11041 SET_CLASSTYPE_INTERFACE_KNOWN (t);
11042 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
11043 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
11046 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
11047 rest_of_type_compilation (t, 1);
11051 /* Called from do_type_instantiation through binding_table_foreach to
11052 do recursive instantiation for the type bound in ENTRY. */
11054 bt_instantiate_type_proc (binding_entry entry, void *data)
11056 tree storage = *(tree *) data;
11058 if (IS_AGGR_TYPE (entry->type)
11059 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
11060 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
11063 /* Called from do_type_instantiation to instantiate a member
11064 (a member function or a static member variable) of an
11065 explicitly instantiated class template. */
11067 instantiate_class_member (tree decl, int extern_p)
11069 mark_decl_instantiated (decl, extern_p);
11071 instantiate_decl (decl, /*defer_ok=*/1,
11072 /*expl_inst_class_mem_p=*/true);
11075 /* Perform an explicit instantiation of template class T. STORAGE, if
11076 non-null, is the RID for extern, inline or static. COMPLAIN is
11077 nonzero if this is called from the parser, zero if called recursively,
11078 since the standard is unclear (as detailed below). */
11081 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
11086 int previous_instantiation_extern_p = 0;
11088 if (TREE_CODE (t) == TYPE_DECL)
11091 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
11093 error ("explicit instantiation of non-template type %qT", t);
11099 if (!COMPLETE_TYPE_P (t))
11101 if (complain & tf_error)
11102 error ("explicit instantiation of %q#T before definition of template",
11107 if (storage != NULL_TREE)
11109 if (pedantic && !in_system_header)
11110 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
11113 if (storage == ridpointers[(int) RID_INLINE])
11115 else if (storage == ridpointers[(int) RID_EXTERN])
11117 else if (storage == ridpointers[(int) RID_STATIC])
11121 error ("storage class %qD applied to template instantiation",
11127 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
11129 /* DR 259 [temp.spec].
11131 Both an explicit instantiation and a declaration of an explicit
11132 specialization shall not appear in a program unless the explicit
11133 instantiation follows a declaration of the explicit specialization.
11135 For a given set of template parameters, if an explicit
11136 instantiation of a template appears after a declaration of an
11137 explicit specialization for that template, the explicit
11138 instantiation has no effect. */
11141 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
11145 No program shall explicitly instantiate any template more
11148 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
11149 instantiation was `extern'. If EXTERN_P then the second is.
11150 These cases are OK. */
11151 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
11153 if (!previous_instantiation_extern_p && !extern_p
11154 && (complain & tf_error))
11155 pedwarn ("duplicate explicit instantiation of %q#T", t);
11157 /* If we've already instantiated the template, just return now. */
11158 if (!CLASSTYPE_INTERFACE_ONLY (t))
11162 mark_class_instantiated (t, extern_p);
11170 /* In contrast to implicit instantiation, where only the
11171 declarations, and not the definitions, of members are
11172 instantiated, we have here:
11176 The explicit instantiation of a class template specialization
11177 implies the instantiation of all of its members not
11178 previously explicitly specialized in the translation unit
11179 containing the explicit instantiation.
11181 Of course, we can't instantiate member template classes, since
11182 we don't have any arguments for them. Note that the standard
11183 is unclear on whether the instantiation of the members are
11184 *explicit* instantiations or not. However, the most natural
11185 interpretation is that it should be an explicit instantiation. */
11188 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
11189 if (TREE_CODE (tmp) == FUNCTION_DECL
11190 && DECL_TEMPLATE_INSTANTIATION (tmp))
11191 instantiate_class_member (tmp, extern_p);
11193 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
11194 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
11195 instantiate_class_member (tmp, extern_p);
11197 if (CLASSTYPE_NESTED_UTDS (t))
11198 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
11199 bt_instantiate_type_proc, &storage);
11203 /* Given a function DECL, which is a specialization of TMPL, modify
11204 DECL to be a re-instantiation of TMPL with the same template
11205 arguments. TMPL should be the template into which tsubst'ing
11206 should occur for DECL, not the most general template.
11208 One reason for doing this is a scenario like this:
11211 void f(const T&, int i);
11213 void g() { f(3, 7); }
11216 void f(const T& t, const int i) { }
11218 Note that when the template is first instantiated, with
11219 instantiate_template, the resulting DECL will have no name for the
11220 first parameter, and the wrong type for the second. So, when we go
11221 to instantiate the DECL, we regenerate it. */
11224 regenerate_decl_from_template (tree decl, tree tmpl)
11226 /* The arguments used to instantiate DECL, from the most general
11231 args = DECL_TI_ARGS (decl);
11232 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
11234 /* Make sure that we can see identifiers, and compute access
11236 push_access_scope (decl);
11238 if (TREE_CODE (decl) == FUNCTION_DECL)
11246 args_depth = TMPL_ARGS_DEPTH (args);
11247 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
11248 if (args_depth > parms_depth)
11249 args = get_innermost_template_args (args, parms_depth);
11251 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
11252 args, tf_error, NULL_TREE);
11254 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
11257 /* Merge parameter declarations. */
11258 decl_parm = skip_artificial_parms_for (decl,
11259 DECL_ARGUMENTS (decl));
11261 = skip_artificial_parms_for (code_pattern,
11262 DECL_ARGUMENTS (code_pattern));
11268 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
11269 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
11270 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
11272 parm_type = type_decays_to (parm_type);
11273 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
11274 TREE_TYPE (decl_parm) = parm_type;
11275 attributes = DECL_ATTRIBUTES (pattern_parm);
11276 if (DECL_ATTRIBUTES (decl_parm) != attributes)
11278 DECL_ATTRIBUTES (decl_parm) = attributes;
11279 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
11281 decl_parm = TREE_CHAIN (decl_parm);
11282 pattern_parm = TREE_CHAIN (pattern_parm);
11285 /* Merge additional specifiers from the CODE_PATTERN. */
11286 if (DECL_DECLARED_INLINE_P (code_pattern)
11287 && !DECL_DECLARED_INLINE_P (decl))
11288 DECL_DECLARED_INLINE_P (decl) = 1;
11289 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
11290 DECL_INLINE (decl) = 1;
11292 else if (TREE_CODE (decl) == VAR_DECL)
11293 DECL_INITIAL (decl) =
11294 tsubst_expr (DECL_INITIAL (code_pattern), args,
11295 tf_error, DECL_TI_TEMPLATE (decl));
11297 gcc_unreachable ();
11299 pop_access_scope (decl);
11302 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
11303 substituted to get DECL. */
11306 template_for_substitution (tree decl)
11308 tree tmpl = DECL_TI_TEMPLATE (decl);
11310 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
11311 for the instantiation. This is not always the most general
11312 template. Consider, for example:
11315 struct S { template <class U> void f();
11316 template <> void f<int>(); };
11318 and an instantiation of S<double>::f<int>. We want TD to be the
11319 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11320 while (/* An instantiation cannot have a definition, so we need a
11321 more general template. */
11322 DECL_TEMPLATE_INSTANTIATION (tmpl)
11323 /* We must also deal with friend templates. Given:
11325 template <class T> struct S {
11326 template <class U> friend void f() {};
11329 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
11330 so far as the language is concerned, but that's still
11331 where we get the pattern for the instantiation from. On
11332 other hand, if the definition comes outside the class, say:
11334 template <class T> struct S {
11335 template <class U> friend void f();
11337 template <class U> friend void f() {}
11339 we don't need to look any further. That's what the check for
11340 DECL_INITIAL is for. */
11341 || (TREE_CODE (decl) == FUNCTION_DECL
11342 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
11343 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
11345 /* The present template, TD, should not be a definition. If it
11346 were a definition, we should be using it! Note that we
11347 cannot restructure the loop to just keep going until we find
11348 a template with a definition, since that might go too far if
11349 a specialization was declared, but not defined. */
11350 gcc_assert (TREE_CODE (decl) != VAR_DECL
11351 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
11353 /* Fetch the more general template. */
11354 tmpl = DECL_TI_TEMPLATE (tmpl);
11360 /* Produce the definition of D, a _DECL generated from a template. If
11361 DEFER_OK is nonzero, then we don't have to actually do the
11362 instantiation now; we just have to do it sometime. Normally it is
11363 an error if this is an explicit instantiation but D is undefined.
11364 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
11365 explicitly instantiated class template. */
11368 instantiate_decl (tree d, int defer_ok,
11369 bool expl_inst_class_mem_p)
11371 tree tmpl = DECL_TI_TEMPLATE (d);
11378 bool pattern_defined;
11380 location_t saved_loc = input_location;
11383 /* This function should only be used to instantiate templates for
11384 functions and static member variables. */
11385 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
11386 || TREE_CODE (d) == VAR_DECL);
11388 /* Variables are never deferred; if instantiation is required, they
11389 are instantiated right away. That allows for better code in the
11390 case that an expression refers to the value of the variable --
11391 if the variable has a constant value the referring expression can
11392 take advantage of that fact. */
11393 if (TREE_CODE (d) == VAR_DECL)
11396 /* Don't instantiate cloned functions. Instead, instantiate the
11397 functions they cloned. */
11398 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
11399 d = DECL_CLONED_FUNCTION (d);
11401 if (DECL_TEMPLATE_INSTANTIATED (d))
11402 /* D has already been instantiated. It might seem reasonable to
11403 check whether or not D is an explicit instantiation, and, if so,
11404 stop here. But when an explicit instantiation is deferred
11405 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
11406 is set, even though we still need to do the instantiation. */
11409 /* If we already have a specialization of this declaration, then
11410 there's no reason to instantiate it. Note that
11411 retrieve_specialization gives us both instantiations and
11412 specializations, so we must explicitly check
11413 DECL_TEMPLATE_SPECIALIZATION. */
11414 gen_tmpl = most_general_template (tmpl);
11415 gen_args = DECL_TI_ARGS (d);
11416 spec = retrieve_specialization (gen_tmpl, gen_args,
11417 /*class_specializations_p=*/false);
11418 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
11421 /* This needs to happen before any tsubsting. */
11422 if (! push_tinst_level (d))
11425 timevar_push (TV_PARSE);
11427 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
11428 for the instantiation. */
11429 td = template_for_substitution (d);
11430 code_pattern = DECL_TEMPLATE_RESULT (td);
11432 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
11433 || DECL_TEMPLATE_SPECIALIZATION (td))
11434 /* In the case of a friend template whose definition is provided
11435 outside the class, we may have too many arguments. Drop the
11436 ones we don't need. The same is true for specializations. */
11437 args = get_innermost_template_args
11438 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
11442 if (TREE_CODE (d) == FUNCTION_DECL)
11443 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
11445 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
11447 /* We may be in the middle of deferred access check. Disable it now. */
11448 push_deferring_access_checks (dk_no_deferred);
11450 /* Unless an explicit instantiation directive has already determined
11451 the linkage of D, remember that a definition is available for
11453 if (pattern_defined
11454 && !DECL_INTERFACE_KNOWN (d)
11455 && !DECL_NOT_REALLY_EXTERN (d))
11456 mark_definable (d);
11458 input_location = DECL_SOURCE_LOCATION (d);
11460 /* If D is a member of an explicitly instantiated class template,
11461 and no definition is available, treat it like an implicit
11463 if (!pattern_defined && expl_inst_class_mem_p
11464 && DECL_EXPLICIT_INSTANTIATION (d))
11466 DECL_NOT_REALLY_EXTERN (d) = 0;
11467 DECL_INTERFACE_KNOWN (d) = 0;
11468 SET_DECL_IMPLICIT_INSTANTIATION (d);
11473 /* Recheck the substitutions to obtain any warning messages
11474 about ignoring cv qualifiers. */
11475 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
11476 tree type = TREE_TYPE (gen);
11478 /* Make sure that we can see identifiers, and compute access
11479 correctly. D is already the target FUNCTION_DECL with the
11481 push_access_scope (d);
11483 if (TREE_CODE (gen) == FUNCTION_DECL)
11485 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_error | tf_warning, d);
11486 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
11487 tf_error | tf_warning, d);
11488 /* Don't simply tsubst the function type, as that will give
11489 duplicate warnings about poor parameter qualifications.
11490 The function arguments are the same as the decl_arguments
11491 without the top level cv qualifiers. */
11492 type = TREE_TYPE (type);
11494 tsubst (type, gen_args, tf_error | tf_warning, d);
11496 pop_access_scope (d);
11499 /* Check to see whether we know that this template will be
11500 instantiated in some other file, as with "extern template"
11502 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
11503 /* In general, we do not instantiate such templates... */
11505 /* ... but we instantiate inline functions so that we can inline
11507 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
11508 /* ... we instantiate static data members whose values are
11509 needed in integral constant expressions. */
11510 && ! (TREE_CODE (d) == VAR_DECL
11511 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
11513 /* Defer all other templates, unless we have been explicitly
11514 forbidden from doing so. */
11515 if (/* If there is no definition, we cannot instantiate the
11518 /* If it's OK to postpone instantiation, do so. */
11520 /* If this is a static data member that will be defined
11521 elsewhere, we don't want to instantiate the entire data
11522 member, but we do want to instantiate the initializer so that
11523 we can substitute that elsewhere. */
11524 || (external_p && TREE_CODE (d) == VAR_DECL))
11526 /* The definition of the static data member is now required so
11527 we must substitute the initializer. */
11528 if (TREE_CODE (d) == VAR_DECL
11529 && !DECL_INITIAL (d)
11530 && DECL_INITIAL (code_pattern))
11532 push_nested_class (DECL_CONTEXT (d));
11534 = tsubst_expr (DECL_INITIAL (code_pattern),
11536 tf_error | tf_warning, NULL_TREE);
11537 pop_nested_class ();
11540 /* We restore the source position here because it's used by
11541 add_pending_template. */
11542 input_location = saved_loc;
11544 if (at_eof && !pattern_defined
11545 && DECL_EXPLICIT_INSTANTIATION (d))
11548 The definition of a non-exported function template, a
11549 non-exported member function template, or a non-exported
11550 member function or static data member of a class template
11551 shall be present in every translation unit in which it is
11552 explicitly instantiated. */
11554 ("explicit instantiation of %qD but no definition available", d);
11556 /* ??? Historically, we have instantiated inline functions, even
11557 when marked as "extern template". */
11558 if (!(external_p && TREE_CODE (d) == VAR_DECL))
11559 add_pending_template (d);
11562 /* Tell the repository that D is available in this translation unit
11563 -- and see if it is supposed to be instantiated here. */
11564 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
11566 /* In a PCH file, despite the fact that the repository hasn't
11567 requested instantiation in the PCH it is still possible that
11568 an instantiation will be required in a file that includes the
11571 add_pending_template (d);
11572 /* Instantiate inline functions so that the inliner can do its
11573 job, even though we'll not be emitting a copy of this
11575 if (!(TREE_CODE (d) == FUNCTION_DECL
11576 && flag_inline_trees
11577 && DECL_DECLARED_INLINE_P (d)))
11581 need_push = !cfun || !global_bindings_p ();
11583 push_to_top_level ();
11585 /* Mark D as instantiated so that recursive calls to
11586 instantiate_decl do not try to instantiate it again. */
11587 DECL_TEMPLATE_INSTANTIATED (d) = 1;
11589 /* Regenerate the declaration in case the template has been modified
11590 by a subsequent redeclaration. */
11591 regenerate_decl_from_template (d, td);
11593 /* We already set the file and line above. Reset them now in case
11594 they changed as a result of calling regenerate_decl_from_template. */
11595 input_location = DECL_SOURCE_LOCATION (d);
11597 if (TREE_CODE (d) == VAR_DECL)
11599 /* Clear out DECL_RTL; whatever was there before may not be right
11600 since we've reset the type of the declaration. */
11601 SET_DECL_RTL (d, NULL_RTX);
11602 DECL_IN_AGGR_P (d) = 0;
11604 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
11605 initializer. That function will defer actual emission until
11606 we have a chance to determine linkage. */
11607 DECL_EXTERNAL (d) = 0;
11609 /* Enter the scope of D so that access-checking works correctly. */
11610 push_nested_class (DECL_CONTEXT (d));
11611 cp_finish_decl (d, DECL_INITIAL (d), NULL_TREE, 0);
11612 pop_nested_class ();
11614 else if (TREE_CODE (d) == FUNCTION_DECL)
11616 htab_t saved_local_specializations;
11621 /* Save away the current list, in case we are instantiating one
11622 template from within the body of another. */
11623 saved_local_specializations = local_specializations;
11625 /* Set up the list of local specializations. */
11626 local_specializations = htab_create (37,
11627 hash_local_specialization,
11628 eq_local_specializations,
11631 /* Set up context. */
11632 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
11634 /* Create substitution entries for the parameters. */
11635 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
11636 tmpl_parm = DECL_ARGUMENTS (subst_decl);
11637 spec_parm = DECL_ARGUMENTS (d);
11638 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
11640 register_local_specialization (spec_parm, tmpl_parm);
11641 spec_parm = skip_artificial_parms_for (d, spec_parm);
11642 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
11646 register_local_specialization (spec_parm, tmpl_parm);
11647 tmpl_parm = TREE_CHAIN (tmpl_parm);
11648 spec_parm = TREE_CHAIN (spec_parm);
11650 gcc_assert (!spec_parm);
11652 /* Substitute into the body of the function. */
11653 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
11654 tf_error | tf_warning, tmpl);
11656 /* We don't need the local specializations any more. */
11657 htab_delete (local_specializations);
11658 local_specializations = saved_local_specializations;
11660 /* Finish the function. */
11661 d = finish_function (0);
11662 expand_or_defer_fn (d);
11665 /* We're not deferring instantiation any more. */
11666 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
11669 pop_from_top_level ();
11672 input_location = saved_loc;
11673 pop_deferring_access_checks ();
11674 pop_tinst_level ();
11676 timevar_pop (TV_PARSE);
11681 /* Run through the list of templates that we wish we could
11682 instantiate, and instantiate any we can. RETRIES is the
11683 number of times we retry pending template instantiation. */
11686 instantiate_pending_templates (int retries)
11689 tree last = NULL_TREE;
11691 location_t saved_loc = input_location;
11692 int saved_in_system_header = in_system_header;
11694 /* Instantiating templates may trigger vtable generation. This in turn
11695 may require further template instantiations. We place a limit here
11696 to avoid infinite loop. */
11697 if (pending_templates && retries >= max_tinst_depth)
11699 error ("template instantiation depth exceeds maximum of %d"
11700 " instantiating %q+D, possibly from virtual table generation"
11701 " (use -ftemplate-depth-NN to increase the maximum)",
11702 max_tinst_depth, TREE_VALUE (pending_templates));
11710 t = &pending_templates;
11713 tree instantiation = TREE_VALUE (*t);
11715 reopen_tinst_level (TREE_PURPOSE (*t));
11717 if (TYPE_P (instantiation))
11721 if (!COMPLETE_TYPE_P (instantiation))
11723 instantiate_class_template (instantiation);
11724 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
11725 for (fn = TYPE_METHODS (instantiation);
11727 fn = TREE_CHAIN (fn))
11728 if (! DECL_ARTIFICIAL (fn))
11729 instantiate_decl (fn,
11731 /*expl_inst_class_mem_p=*/false);
11732 if (COMPLETE_TYPE_P (instantiation))
11736 if (COMPLETE_TYPE_P (instantiation))
11737 /* If INSTANTIATION has been instantiated, then we don't
11738 need to consider it again in the future. */
11739 *t = TREE_CHAIN (*t);
11743 t = &TREE_CHAIN (*t);
11748 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
11749 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
11752 = instantiate_decl (instantiation,
11754 /*expl_inst_class_mem_p=*/false);
11755 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
11759 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
11760 || DECL_TEMPLATE_INSTANTIATED (instantiation))
11761 /* If INSTANTIATION has been instantiated, then we don't
11762 need to consider it again in the future. */
11763 *t = TREE_CHAIN (*t);
11767 t = &TREE_CHAIN (*t);
11771 current_tinst_level = NULL_TREE;
11773 last_pending_template = last;
11775 while (reconsider);
11777 input_location = saved_loc;
11778 in_system_header = saved_in_system_header;
11781 /* Substitute ARGVEC into T, which is a list of initializers for
11782 either base class or a non-static data member. The TREE_PURPOSEs
11783 are DECLs, and the TREE_VALUEs are the initializer values. Used by
11784 instantiate_decl. */
11787 tsubst_initializer_list (tree t, tree argvec)
11789 tree inits = NULL_TREE;
11791 for (; t; t = TREE_CHAIN (t))
11796 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_error | tf_warning,
11798 decl = expand_member_init (decl);
11799 if (decl && !DECL_P (decl))
11800 in_base_initializer = 1;
11802 init = tsubst_expr (TREE_VALUE (t), argvec, tf_error | tf_warning,
11804 in_base_initializer = 0;
11808 init = build_tree_list (decl, init);
11809 TREE_CHAIN (init) = inits;
11816 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
11819 set_current_access_from_decl (tree decl)
11821 if (TREE_PRIVATE (decl))
11822 current_access_specifier = access_private_node;
11823 else if (TREE_PROTECTED (decl))
11824 current_access_specifier = access_protected_node;
11826 current_access_specifier = access_public_node;
11829 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
11830 is the instantiation (which should have been created with
11831 start_enum) and ARGS are the template arguments to use. */
11834 tsubst_enum (tree tag, tree newtag, tree args)
11838 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
11843 decl = TREE_VALUE (e);
11844 /* Note that in a template enum, the TREE_VALUE is the
11845 CONST_DECL, not the corresponding INTEGER_CST. */
11846 value = tsubst_expr (DECL_INITIAL (decl),
11847 args, tf_error | tf_warning,
11850 /* Give this enumeration constant the correct access. */
11851 set_current_access_from_decl (decl);
11853 /* Actually build the enumerator itself. */
11854 build_enumerator (DECL_NAME (decl), value, newtag);
11857 finish_enum (newtag);
11858 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
11859 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
11862 /* DECL is a FUNCTION_DECL that is a template specialization. Return
11863 its type -- but without substituting the innermost set of template
11864 arguments. So, innermost set of template parameters will appear in
11868 get_mostly_instantiated_function_type (tree decl)
11876 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
11877 targs = DECL_TI_ARGS (decl);
11878 tparms = DECL_TEMPLATE_PARMS (tmpl);
11879 parm_depth = TMPL_PARMS_DEPTH (tparms);
11881 /* There should be as many levels of arguments as there are levels
11883 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
11885 fn_type = TREE_TYPE (tmpl);
11887 if (parm_depth == 1)
11888 /* No substitution is necessary. */
11892 int i, save_access_control;
11895 /* Replace the innermost level of the TARGS with NULL_TREEs to
11896 let tsubst know not to substitute for those parameters. */
11897 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
11898 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
11899 SET_TMPL_ARGS_LEVEL (partial_args, i,
11900 TMPL_ARGS_LEVEL (targs, i));
11901 SET_TMPL_ARGS_LEVEL (partial_args,
11902 TMPL_ARGS_DEPTH (targs),
11903 make_tree_vec (DECL_NTPARMS (tmpl)));
11905 /* Disable access control as this function is used only during
11907 save_access_control = flag_access_control;
11908 flag_access_control = 0;
11910 ++processing_template_decl;
11911 /* Now, do the (partial) substitution to figure out the
11912 appropriate function type. */
11913 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
11914 --processing_template_decl;
11916 /* Substitute into the template parameters to obtain the real
11917 innermost set of parameters. This step is important if the
11918 innermost set of template parameters contains value
11919 parameters whose types depend on outer template parameters. */
11920 TREE_VEC_LENGTH (partial_args)--;
11921 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
11923 flag_access_control = save_access_control;
11929 /* Return truthvalue if we're processing a template different from
11930 the last one involved in diagnostics. */
11932 problematic_instantiation_changed (void)
11934 return last_template_error_tick != tinst_level_tick;
11937 /* Remember current template involved in diagnostics. */
11939 record_last_problematic_instantiation (void)
11941 last_template_error_tick = tinst_level_tick;
11945 current_instantiation (void)
11947 return current_tinst_level;
11950 /* [temp.param] Check that template non-type parm TYPE is of an allowable
11951 type. Return zero for ok, nonzero for disallowed. Issue error and
11952 warning messages under control of COMPLAIN. */
11955 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
11957 if (INTEGRAL_TYPE_P (type))
11959 else if (POINTER_TYPE_P (type))
11961 else if (TYPE_PTR_TO_MEMBER_P (type))
11963 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11965 else if (TREE_CODE (type) == TYPENAME_TYPE)
11968 if (complain & tf_error)
11969 error ("%q#T is not a valid type for a template constant parameter", type);
11973 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
11974 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
11977 dependent_type_p_r (tree type)
11983 A type is dependent if it is:
11985 -- a template parameter. Template template parameters are types
11986 for us (since TYPE_P holds true for them) so we handle
11988 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
11989 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
11991 /* -- a qualified-id with a nested-name-specifier which contains a
11992 class-name that names a dependent type or whose unqualified-id
11993 names a dependent type. */
11994 if (TREE_CODE (type) == TYPENAME_TYPE)
11996 /* -- a cv-qualified type where the cv-unqualified type is
11998 type = TYPE_MAIN_VARIANT (type);
11999 /* -- a compound type constructed from any dependent type. */
12000 if (TYPE_PTR_TO_MEMBER_P (type))
12001 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
12002 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
12004 else if (TREE_CODE (type) == POINTER_TYPE
12005 || TREE_CODE (type) == REFERENCE_TYPE)
12006 return dependent_type_p (TREE_TYPE (type));
12007 else if (TREE_CODE (type) == FUNCTION_TYPE
12008 || TREE_CODE (type) == METHOD_TYPE)
12012 if (dependent_type_p (TREE_TYPE (type)))
12014 for (arg_type = TYPE_ARG_TYPES (type);
12016 arg_type = TREE_CHAIN (arg_type))
12017 if (dependent_type_p (TREE_VALUE (arg_type)))
12021 /* -- an array type constructed from any dependent type or whose
12022 size is specified by a constant expression that is
12023 value-dependent. */
12024 if (TREE_CODE (type) == ARRAY_TYPE)
12026 if (TYPE_DOMAIN (type)
12027 && ((value_dependent_expression_p
12028 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12029 || (type_dependent_expression_p
12030 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
12032 return dependent_type_p (TREE_TYPE (type));
12035 /* -- a template-id in which either the template name is a template
12037 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
12039 /* ... or any of the template arguments is a dependent type or
12040 an expression that is type-dependent or value-dependent. */
12041 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
12042 && (any_dependent_template_arguments_p
12043 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
12046 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
12047 expression is not type-dependent, then it should already been
12049 if (TREE_CODE (type) == TYPEOF_TYPE)
12052 /* The standard does not specifically mention types that are local
12053 to template functions or local classes, but they should be
12054 considered dependent too. For example:
12056 template <int I> void f() {
12061 The size of `E' cannot be known until the value of `I' has been
12062 determined. Therefore, `E' must be considered dependent. */
12063 scope = TYPE_CONTEXT (type);
12064 if (scope && TYPE_P (scope))
12065 return dependent_type_p (scope);
12066 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12067 return type_dependent_expression_p (scope);
12069 /* Other types are non-dependent. */
12073 /* Returns TRUE if TYPE is dependent, in the sense of
12074 [temp.dep.type]. */
12077 dependent_type_p (tree type)
12079 /* If there are no template parameters in scope, then there can't be
12080 any dependent types. */
12081 if (!processing_template_decl)
12084 /* If the type is NULL, we have not computed a type for the entity
12085 in question; in that case, the type is dependent. */
12089 /* Erroneous types can be considered non-dependent. */
12090 if (type == error_mark_node)
12093 /* If we have not already computed the appropriate value for TYPE,
12095 if (!TYPE_DEPENDENT_P_VALID (type))
12097 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
12098 TYPE_DEPENDENT_P_VALID (type) = 1;
12101 return TYPE_DEPENDENT_P (type);
12104 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
12107 dependent_scope_ref_p (tree expression, bool criterion (tree))
12112 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
12114 if (!TYPE_P (TREE_OPERAND (expression, 0)))
12117 scope = TREE_OPERAND (expression, 0);
12118 name = TREE_OPERAND (expression, 1);
12122 An id-expression is type-dependent if it contains a
12123 nested-name-specifier that contains a class-name that names a
12125 /* The suggested resolution to Core Issue 2 implies that if the
12126 qualifying type is the current class, then we must peek
12129 && currently_open_class (scope)
12130 && !criterion (name))
12132 if (dependent_type_p (scope))
12138 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
12139 [temp.dep.constexpr] */
12142 value_dependent_expression_p (tree expression)
12144 if (!processing_template_decl)
12147 /* A name declared with a dependent type. */
12148 if (DECL_P (expression) && type_dependent_expression_p (expression))
12151 switch (TREE_CODE (expression))
12153 case IDENTIFIER_NODE:
12154 /* A name that has not been looked up -- must be dependent. */
12157 case TEMPLATE_PARM_INDEX:
12158 /* A non-type template parm. */
12162 /* A non-type template parm. */
12163 if (DECL_TEMPLATE_PARM_P (expression))
12168 /* A constant with integral or enumeration type and is initialized
12169 with an expression that is value-dependent. */
12170 if (DECL_INITIAL (expression)
12171 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
12172 && value_dependent_expression_p (DECL_INITIAL (expression)))
12176 case DYNAMIC_CAST_EXPR:
12177 case STATIC_CAST_EXPR:
12178 case CONST_CAST_EXPR:
12179 case REINTERPRET_CAST_EXPR:
12181 /* These expressions are value-dependent if the type to which
12182 the cast occurs is dependent or the expression being casted
12183 is value-dependent. */
12185 tree type = TREE_TYPE (expression);
12187 if (dependent_type_p (type))
12190 /* A functional cast has a list of operands. */
12191 expression = TREE_OPERAND (expression, 0);
12194 /* If there are no operands, it must be an expression such
12195 as "int()". This should not happen for aggregate types
12196 because it would form non-constant expressions. */
12197 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
12202 if (TREE_CODE (expression) == TREE_LIST)
12204 for (; expression; expression = TREE_CHAIN (expression))
12205 if (value_dependent_expression_p (TREE_VALUE (expression)))
12210 return value_dependent_expression_p (expression);
12215 /* A `sizeof' expression is value-dependent if the operand is
12217 expression = TREE_OPERAND (expression, 0);
12218 if (TYPE_P (expression))
12219 return dependent_type_p (expression);
12220 return type_dependent_expression_p (expression);
12223 return dependent_scope_ref_p (expression, value_dependent_expression_p);
12225 case COMPONENT_REF:
12226 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
12227 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
12230 /* A CALL_EXPR is value-dependent if any argument is
12231 value-dependent. Why do we have to handle CALL_EXPRs in this
12232 function at all? First, some function calls, those for which
12233 value_dependent_expression_p is true, man appear in constant
12234 expressions. Second, there appear to be bugs which result in
12235 other CALL_EXPRs reaching this point. */
12237 tree function = TREE_OPERAND (expression, 0);
12238 tree args = TREE_OPERAND (expression, 1);
12240 if (value_dependent_expression_p (function))
12246 if (TREE_CODE (args) == TREE_LIST)
12248 for (; args; args = TREE_CHAIN (args))
12249 if (value_dependent_expression_p (TREE_VALUE (args)))
12254 return value_dependent_expression_p (args);
12258 /* A constant expression is value-dependent if any subexpression is
12259 value-dependent. */
12260 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
12262 case tcc_reference:
12264 return (value_dependent_expression_p
12265 (TREE_OPERAND (expression, 0)));
12267 case tcc_comparison:
12269 return ((value_dependent_expression_p
12270 (TREE_OPERAND (expression, 0)))
12271 || (value_dependent_expression_p
12272 (TREE_OPERAND (expression, 1))));
12274 case tcc_expression:
12277 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
12278 /* In some cases, some of the operands may be missing.
12279 (For example, in the case of PREDECREMENT_EXPR, the
12280 amount to increment by may be missing.) That doesn't
12281 make the expression dependent. */
12282 if (TREE_OPERAND (expression, i)
12283 && (value_dependent_expression_p
12284 (TREE_OPERAND (expression, i))))
12294 /* The expression is not value-dependent. */
12298 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
12299 [temp.dep.expr]. */
12302 type_dependent_expression_p (tree expression)
12304 if (!processing_template_decl)
12307 if (expression == error_mark_node)
12310 /* An unresolved name is always dependent. */
12311 if (TREE_CODE (expression) == IDENTIFIER_NODE)
12314 /* Some expression forms are never type-dependent. */
12315 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
12316 || TREE_CODE (expression) == SIZEOF_EXPR
12317 || TREE_CODE (expression) == ALIGNOF_EXPR
12318 || TREE_CODE (expression) == TYPEID_EXPR
12319 || TREE_CODE (expression) == DELETE_EXPR
12320 || TREE_CODE (expression) == VEC_DELETE_EXPR
12321 || TREE_CODE (expression) == THROW_EXPR)
12324 /* The types of these expressions depends only on the type to which
12325 the cast occurs. */
12326 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
12327 || TREE_CODE (expression) == STATIC_CAST_EXPR
12328 || TREE_CODE (expression) == CONST_CAST_EXPR
12329 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
12330 || TREE_CODE (expression) == CAST_EXPR)
12331 return dependent_type_p (TREE_TYPE (expression));
12333 /* The types of these expressions depends only on the type created
12334 by the expression. */
12335 if (TREE_CODE (expression) == NEW_EXPR
12336 || TREE_CODE (expression) == VEC_NEW_EXPR)
12338 /* For NEW_EXPR tree nodes created inside a template, either
12339 the object type itself or a TREE_LIST may appear as the
12341 tree type = TREE_OPERAND (expression, 1);
12342 if (TREE_CODE (type) == TREE_LIST)
12343 /* This is an array type. We need to check array dimensions
12345 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
12346 || value_dependent_expression_p
12347 (TREE_OPERAND (TREE_VALUE (type), 1));
12349 return dependent_type_p (type);
12352 if (TREE_CODE (expression) == SCOPE_REF
12353 && dependent_scope_ref_p (expression,
12354 type_dependent_expression_p))
12357 if (TREE_CODE (expression) == FUNCTION_DECL
12358 && DECL_LANG_SPECIFIC (expression)
12359 && DECL_TEMPLATE_INFO (expression)
12360 && (any_dependent_template_arguments_p
12361 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
12364 if (TREE_CODE (expression) == TEMPLATE_DECL
12365 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
12368 if (TREE_TYPE (expression) == unknown_type_node)
12370 if (TREE_CODE (expression) == ADDR_EXPR)
12371 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
12372 if (TREE_CODE (expression) == COMPONENT_REF
12373 || TREE_CODE (expression) == OFFSET_REF)
12375 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
12377 expression = TREE_OPERAND (expression, 1);
12378 if (TREE_CODE (expression) == IDENTIFIER_NODE)
12381 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
12382 if (TREE_CODE (expression) == SCOPE_REF)
12385 if (TREE_CODE (expression) == BASELINK)
12386 expression = BASELINK_FUNCTIONS (expression);
12388 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
12390 if (any_dependent_template_arguments_p
12391 (TREE_OPERAND (expression, 1)))
12393 expression = TREE_OPERAND (expression, 0);
12395 gcc_assert (TREE_CODE (expression) == OVERLOAD
12396 || TREE_CODE (expression) == FUNCTION_DECL);
12400 if (type_dependent_expression_p (OVL_CURRENT (expression)))
12402 expression = OVL_NEXT (expression);
12407 return (dependent_type_p (TREE_TYPE (expression)));
12410 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
12411 contains a type-dependent expression. */
12414 any_type_dependent_arguments_p (tree args)
12418 tree arg = TREE_VALUE (args);
12420 if (type_dependent_expression_p (arg))
12422 args = TREE_CHAIN (args);
12427 /* Returns TRUE if the ARG (a template argument) is dependent. */
12430 dependent_template_arg_p (tree arg)
12432 if (!processing_template_decl)
12435 if (TREE_CODE (arg) == TEMPLATE_DECL
12436 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12437 return dependent_template_p (arg);
12438 else if (TYPE_P (arg))
12439 return dependent_type_p (arg);
12441 return (type_dependent_expression_p (arg)
12442 || value_dependent_expression_p (arg));
12445 /* Returns true if ARGS (a collection of template arguments) contains
12446 any dependent arguments. */
12449 any_dependent_template_arguments_p (tree args)
12457 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
12459 tree level = TMPL_ARGS_LEVEL (args, i + 1);
12460 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
12461 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
12468 /* Returns TRUE if the template TMPL is dependent. */
12471 dependent_template_p (tree tmpl)
12473 if (TREE_CODE (tmpl) == OVERLOAD)
12477 if (dependent_template_p (OVL_FUNCTION (tmpl)))
12479 tmpl = OVL_CHAIN (tmpl);
12484 /* Template template parameters are dependent. */
12485 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
12486 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
12488 /* So are names that have not been looked up. */
12489 if (TREE_CODE (tmpl) == SCOPE_REF
12490 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
12492 /* So are member templates of dependent classes. */
12493 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
12494 return dependent_type_p (DECL_CONTEXT (tmpl));
12498 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
12501 dependent_template_id_p (tree tmpl, tree args)
12503 return (dependent_template_p (tmpl)
12504 || any_dependent_template_arguments_p (args));
12507 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
12508 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
12509 can be found. Note that this function peers inside uninstantiated
12510 templates and therefore should be used only in extremely limited
12511 situations. ONLY_CURRENT_P restricts this peering to the currently
12512 open classes hierarchy (which is required when comparing types). */
12515 resolve_typename_type (tree type, bool only_current_p)
12523 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
12525 scope = TYPE_CONTEXT (type);
12526 name = TYPE_IDENTIFIER (type);
12528 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
12529 it first before we can figure out what NAME refers to. */
12530 if (TREE_CODE (scope) == TYPENAME_TYPE)
12531 scope = resolve_typename_type (scope, only_current_p);
12532 /* If we don't know what SCOPE refers to, then we cannot resolve the
12534 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
12535 return error_mark_node;
12536 /* If the SCOPE is a template type parameter, we have no way of
12537 resolving the name. */
12538 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
12540 /* If the SCOPE is not the current instantiation, there's no reason
12541 to look inside it. */
12542 if (only_current_p && !currently_open_class (scope))
12543 return error_mark_node;
12544 /* If SCOPE is a partial instantiation, it will not have a valid
12545 TYPE_FIELDS list, so use the original template. */
12546 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
12547 /* Enter the SCOPE so that name lookup will be resolved as if we
12548 were in the class definition. In particular, SCOPE will no
12549 longer be considered a dependent type. */
12550 pushed_scope = push_scope (scope);
12551 /* Look up the declaration. */
12552 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
12553 /* Obtain the set of qualifiers applied to the TYPE. */
12554 quals = cp_type_quals (type);
12555 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
12556 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
12558 type = error_mark_node;
12559 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
12560 && TREE_CODE (decl) == TYPE_DECL)
12561 type = TREE_TYPE (decl);
12562 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
12563 && DECL_CLASS_TEMPLATE_P (decl))
12567 /* Obtain the template and the arguments. */
12568 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
12569 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
12570 /* Instantiate the template. */
12571 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
12572 /*entering_scope=*/0, tf_error | tf_user);
12575 type = error_mark_node;
12576 /* Qualify the resulting type. */
12577 if (type != error_mark_node && quals)
12578 type = cp_build_qualified_type (type, quals);
12579 /* Leave the SCOPE. */
12581 pop_scope (pushed_scope);
12586 /* EXPR is an expression which is not type-dependent. Return a proxy
12587 for EXPR that can be used to compute the types of larger
12588 expressions containing EXPR. */
12591 build_non_dependent_expr (tree expr)
12595 /* Preserve null pointer constants so that the type of things like
12596 "p == 0" where "p" is a pointer can be determined. */
12597 if (null_ptr_cst_p (expr))
12599 /* Preserve OVERLOADs; the functions must be available to resolve
12601 inner_expr = (TREE_CODE (expr) == ADDR_EXPR ?
12602 TREE_OPERAND (expr, 0) : expr);
12603 if (is_overloaded_fn (inner_expr)
12604 || TREE_CODE (inner_expr) == OFFSET_REF)
12606 /* There is no need to return a proxy for a variable. */
12607 if (TREE_CODE (expr) == VAR_DECL)
12609 /* Preserve string constants; conversions from string constants to
12610 "char *" are allowed, even though normally a "const char *"
12611 cannot be used to initialize a "char *". */
12612 if (TREE_CODE (expr) == STRING_CST)
12614 /* Preserve arithmetic constants, as an optimization -- there is no
12615 reason to create a new node. */
12616 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
12618 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
12619 There is at least one place where we want to know that a
12620 particular expression is a throw-expression: when checking a ?:
12621 expression, there are special rules if the second or third
12622 argument is a throw-expression. */
12623 if (TREE_CODE (expr) == THROW_EXPR)
12626 if (TREE_CODE (expr) == COND_EXPR)
12627 return build3 (COND_EXPR,
12629 TREE_OPERAND (expr, 0),
12630 (TREE_OPERAND (expr, 1)
12631 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
12632 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
12633 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
12634 if (TREE_CODE (expr) == COMPOUND_EXPR
12635 && !COMPOUND_EXPR_OVERLOADED (expr))
12636 return build2 (COMPOUND_EXPR,
12638 TREE_OPERAND (expr, 0),
12639 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
12641 /* Otherwise, build a NON_DEPENDENT_EXPR.
12643 REFERENCE_TYPEs are not stripped for expressions in templates
12644 because doing so would play havoc with mangling. Consider, for
12647 template <typename T> void f<T& g>() { g(); }
12649 In the body of "f", the expression for "g" will have
12650 REFERENCE_TYPE, even though the standard says that it should
12651 not. The reason is that we must preserve the syntactic form of
12652 the expression so that mangling (say) "f<g>" inside the body of
12653 "f" works out correctly. Therefore, the REFERENCE_TYPE is
12655 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
12658 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
12659 Return a new TREE_LIST with the various arguments replaced with
12660 equivalent non-dependent expressions. */
12663 build_non_dependent_args (tree args)
12668 new_args = NULL_TREE;
12669 for (a = args; a; a = TREE_CHAIN (a))
12670 new_args = tree_cons (NULL_TREE,
12671 build_non_dependent_expr (TREE_VALUE (a)),
12673 return nreverse (new_args);
12676 #include "gt-cp-pt.h"