1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
31 #include "coretypes.h"
35 #include "pointer-set.h"
39 #include "cp-objcp-common.h"
40 #include "tree-inline.h"
47 #include "tree-iterator.h"
50 /* The type of functions taking a tree, and some additional data, and
52 typedef int (*tree_fn_t) (tree, void*);
54 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work.
57 The TREE_PURPOSE of each entry is either a DECL (for a function or
58 static data member), or a TYPE (for a class) indicating what we are
59 hoping to instantiate. The TREE_VALUE is not used. */
60 static GTY(()) tree pending_templates;
61 static GTY(()) tree last_pending_template;
63 int processing_template_parmlist;
64 static int template_header_count;
66 static GTY(()) tree saved_trees;
67 static VEC(int,heap) *inline_parm_levels;
69 static GTY(()) tree current_tinst_level;
71 static GTY(()) tree saved_access_scope;
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76 static tree cur_stmt_expr;
78 /* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
81 static htab_t local_specializations;
83 /* Contains canonical template parameter types. The vector is indexed by
84 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
85 TREE_LIST, whose TREE_VALUEs contain the canonical template
86 parameters of various types and levels. */
87 static GTY(()) VEC(tree,gc) *canonical_template_parms;
89 #define UNIFY_ALLOW_NONE 0
90 #define UNIFY_ALLOW_MORE_CV_QUAL 1
91 #define UNIFY_ALLOW_LESS_CV_QUAL 2
92 #define UNIFY_ALLOW_DERIVED 4
93 #define UNIFY_ALLOW_INTEGER 8
94 #define UNIFY_ALLOW_OUTER_LEVEL 16
95 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
96 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
98 static void push_access_scope (tree);
99 static void pop_access_scope (tree);
100 static int resolve_overloaded_unification (tree, tree, tree, tree,
101 unification_kind_t, int);
102 static int try_one_overload (tree, tree, tree, tree, tree,
103 unification_kind_t, int, bool);
104 static int unify (tree, tree, tree, tree, int);
105 static void add_pending_template (tree);
106 static int push_tinst_level (tree);
107 static void pop_tinst_level (void);
108 static void reopen_tinst_level (tree);
109 static tree tsubst_initializer_list (tree, tree);
110 static tree get_class_bindings (tree, tree, tree);
111 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
113 static void tsubst_enum (tree, tree, tree);
114 static tree add_to_template_args (tree, tree);
115 static tree add_outermost_template_args (tree, tree);
116 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
117 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
118 static int type_unification_real (tree, tree, tree, tree,
119 int, unification_kind_t, int);
120 static void note_template_header (int);
121 static tree convert_nontype_argument_function (tree, tree);
122 static tree convert_nontype_argument (tree, tree);
123 static tree convert_template_argument (tree, tree, tree,
124 tsubst_flags_t, int, tree);
125 static int for_each_template_parm (tree, tree_fn_t, void*,
126 struct pointer_set_t*);
127 static tree build_template_parm_index (int, int, int, tree, tree);
128 static int inline_needs_template_parms (tree);
129 static void push_inline_template_parms_recursive (tree, int);
130 static tree retrieve_local_specialization (tree);
131 static void register_local_specialization (tree, tree);
132 static tree reduce_template_parm_level (tree, tree, int);
133 static int mark_template_parm (tree, void *);
134 static int template_parm_this_level_p (tree, void *);
135 static tree tsubst_friend_function (tree, tree);
136 static tree tsubst_friend_class (tree, tree);
137 static int can_complete_type_without_circularity (tree);
138 static tree get_bindings (tree, tree, tree, bool);
139 static int template_decl_level (tree);
140 static int check_cv_quals_for_unify (int, tree, tree);
141 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
142 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
143 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
144 static void regenerate_decl_from_template (tree, tree);
145 static tree most_specialized_class (tree, tree);
146 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
147 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
148 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
149 static bool check_specialization_scope (void);
150 static tree process_partial_specialization (tree);
151 static void set_current_access_from_decl (tree);
152 static void check_default_tmpl_args (tree, tree, int, int);
153 static tree get_template_base (tree, tree, tree, tree);
154 static tree try_class_unification (tree, tree, tree, tree);
155 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
157 static int template_args_equal (tree, tree);
158 static void tsubst_default_arguments (tree);
159 static tree for_each_template_parm_r (tree *, int *, void *);
160 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
161 static void copy_default_args_to_explicit_spec (tree);
162 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
163 static int eq_local_specializations (const void *, const void *);
164 static bool any_template_arguments_need_structural_equality_p (tree);
165 static bool dependent_type_p_r (tree);
166 static tree tsubst (tree, tree, tsubst_flags_t, tree);
167 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
168 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
170 /* Make the current scope suitable for access checking when we are
171 processing T. T can be FUNCTION_DECL for instantiated function
172 template, or VAR_DECL for static member variable (need by
173 instantiate_decl). */
176 push_access_scope (tree t)
178 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
179 || TREE_CODE (t) == VAR_DECL);
181 if (DECL_FRIEND_CONTEXT (t))
182 push_nested_class (DECL_FRIEND_CONTEXT (t));
183 else if (DECL_CLASS_SCOPE_P (t))
184 push_nested_class (DECL_CONTEXT (t));
186 push_to_top_level ();
188 if (TREE_CODE (t) == FUNCTION_DECL)
190 saved_access_scope = tree_cons
191 (NULL_TREE, current_function_decl, saved_access_scope);
192 current_function_decl = t;
196 /* Restore the scope set up by push_access_scope. T is the node we
200 pop_access_scope (tree t)
202 if (TREE_CODE (t) == FUNCTION_DECL)
204 current_function_decl = TREE_VALUE (saved_access_scope);
205 saved_access_scope = TREE_CHAIN (saved_access_scope);
208 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
211 pop_from_top_level ();
214 /* Do any processing required when DECL (a member template
215 declaration) is finished. Returns the TEMPLATE_DECL corresponding
216 to DECL, unless it is a specialization, in which case the DECL
217 itself is returned. */
220 finish_member_template_decl (tree decl)
222 if (decl == error_mark_node)
223 return error_mark_node;
225 gcc_assert (DECL_P (decl));
227 if (TREE_CODE (decl) == TYPE_DECL)
231 type = TREE_TYPE (decl);
232 if (IS_AGGR_TYPE (type)
233 && CLASSTYPE_TEMPLATE_INFO (type)
234 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
236 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
237 check_member_template (tmpl);
242 else if (TREE_CODE (decl) == FIELD_DECL)
243 error ("data member %qD cannot be a member template", decl);
244 else if (DECL_TEMPLATE_INFO (decl))
246 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
248 check_member_template (DECL_TI_TEMPLATE (decl));
249 return DECL_TI_TEMPLATE (decl);
255 error ("invalid member template declaration %qD", decl);
257 return error_mark_node;
260 /* Returns the template nesting level of the indicated class TYPE.
270 A<T>::B<U> has depth two, while A<T> has depth one.
271 Both A<T>::B<int> and A<int>::B<U> have depth one, if
272 they are instantiations, not specializations.
274 This function is guaranteed to return 0 if passed NULL_TREE so
275 that, for example, `template_class_depth (current_class_type)' is
279 template_class_depth (tree type)
284 type && TREE_CODE (type) != NAMESPACE_DECL;
285 type = (TREE_CODE (type) == FUNCTION_DECL)
286 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
288 if (TREE_CODE (type) != FUNCTION_DECL)
290 if (CLASSTYPE_TEMPLATE_INFO (type)
291 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
292 && uses_template_parms (CLASSTYPE_TI_ARGS (type)))
297 if (DECL_TEMPLATE_INFO (type)
298 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
299 && uses_template_parms (DECL_TI_ARGS (type)))
307 /* Returns 1 if processing DECL as part of do_pending_inlines
308 needs us to push template parms. */
311 inline_needs_template_parms (tree decl)
313 if (! DECL_TEMPLATE_INFO (decl))
316 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
317 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
320 /* Subroutine of maybe_begin_member_template_processing.
321 Push the template parms in PARMS, starting from LEVELS steps into the
322 chain, and ending at the beginning, since template parms are listed
326 push_inline_template_parms_recursive (tree parmlist, int levels)
328 tree parms = TREE_VALUE (parmlist);
332 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
334 ++processing_template_decl;
335 current_template_parms
336 = tree_cons (size_int (processing_template_decl),
337 parms, current_template_parms);
338 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
340 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
342 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
344 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
346 if (parm == error_mark_node)
349 gcc_assert (DECL_P (parm));
351 switch (TREE_CODE (parm))
360 /* Make a CONST_DECL as is done in process_template_parm.
361 It is ugly that we recreate this here; the original
362 version built in process_template_parm is no longer
364 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
366 DECL_ARTIFICIAL (decl) = 1;
367 TREE_CONSTANT (decl) = 1;
368 TREE_INVARIANT (decl) = 1;
369 TREE_READONLY (decl) = 1;
370 DECL_INITIAL (decl) = DECL_INITIAL (parm);
371 SET_DECL_TEMPLATE_PARM_P (decl);
382 /* Restore the template parameter context for a member template or
383 a friend template defined in a class definition. */
386 maybe_begin_member_template_processing (tree decl)
391 if (inline_needs_template_parms (decl))
393 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
394 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
396 if (DECL_TEMPLATE_SPECIALIZATION (decl))
399 parms = TREE_CHAIN (parms);
402 push_inline_template_parms_recursive (parms, levels);
405 /* Remember how many levels of template parameters we pushed so that
406 we can pop them later. */
407 VEC_safe_push (int, heap, inline_parm_levels, levels);
410 /* Undo the effects of maybe_begin_member_template_processing. */
413 maybe_end_member_template_processing (void)
418 if (VEC_length (int, inline_parm_levels) == 0)
421 last = VEC_pop (int, inline_parm_levels);
422 for (i = 0; i < last; ++i)
424 --processing_template_decl;
425 current_template_parms = TREE_CHAIN (current_template_parms);
430 /* Return a new template argument vector which contains all of ARGS,
431 but has as its innermost set of arguments the EXTRA_ARGS. */
434 add_to_template_args (tree args, tree extra_args)
441 extra_depth = TMPL_ARGS_DEPTH (extra_args);
442 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
444 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
445 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
447 for (j = 1; j <= extra_depth; ++j, ++i)
448 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
453 /* Like add_to_template_args, but only the outermost ARGS are added to
454 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
455 (EXTRA_ARGS) levels are added. This function is used to combine
456 the template arguments from a partial instantiation with the
457 template arguments used to attain the full instantiation from the
458 partial instantiation. */
461 add_outermost_template_args (tree args, tree extra_args)
465 /* If there are more levels of EXTRA_ARGS than there are ARGS,
466 something very fishy is going on. */
467 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
469 /* If *all* the new arguments will be the EXTRA_ARGS, just return
471 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
474 /* For the moment, we make ARGS look like it contains fewer levels. */
475 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
477 new_args = add_to_template_args (args, extra_args);
479 /* Now, we restore ARGS to its full dimensions. */
480 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
485 /* Return the N levels of innermost template arguments from the ARGS. */
488 get_innermost_template_args (tree args, int n)
496 /* If N is 1, just return the innermost set of template arguments. */
498 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
500 /* If we're not removing anything, just return the arguments we were
502 extra_levels = TMPL_ARGS_DEPTH (args) - n;
503 gcc_assert (extra_levels >= 0);
504 if (extra_levels == 0)
507 /* Make a new set of arguments, not containing the outer arguments. */
508 new_args = make_tree_vec (n);
509 for (i = 1; i <= n; ++i)
510 SET_TMPL_ARGS_LEVEL (new_args, i,
511 TMPL_ARGS_LEVEL (args, i + extra_levels));
516 /* We've got a template header coming up; push to a new level for storing
520 begin_template_parm_list (void)
522 /* We use a non-tag-transparent scope here, which causes pushtag to
523 put tags in this scope, rather than in the enclosing class or
524 namespace scope. This is the right thing, since we want
525 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
526 global template class, push_template_decl handles putting the
527 TEMPLATE_DECL into top-level scope. For a nested template class,
530 template <class T> struct S1 {
531 template <class T> struct S2 {};
534 pushtag contains special code to call pushdecl_with_scope on the
535 TEMPLATE_DECL for S2. */
536 begin_scope (sk_template_parms, NULL);
537 ++processing_template_decl;
538 ++processing_template_parmlist;
539 note_template_header (0);
542 /* This routine is called when a specialization is declared. If it is
543 invalid to declare a specialization here, an error is reported and
544 false is returned, otherwise this routine will return true. */
547 check_specialization_scope (void)
549 tree scope = current_scope ();
553 An explicit specialization shall be declared in the namespace of
554 which the template is a member, or, for member templates, in the
555 namespace of which the enclosing class or enclosing class
556 template is a member. An explicit specialization of a member
557 function, member class or static data member of a class template
558 shall be declared in the namespace of which the class template
560 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
562 error ("explicit specialization in non-namespace scope %qD", scope);
568 In an explicit specialization declaration for a member of a class
569 template or a member template that appears in namespace scope,
570 the member template and some of its enclosing class templates may
571 remain unspecialized, except that the declaration shall not
572 explicitly specialize a class member template if its enclosing
573 class templates are not explicitly specialized as well. */
574 if (current_template_parms)
576 error ("enclosing class templates are not explicitly specialized");
583 /* We've just seen template <>. */
586 begin_specialization (void)
588 begin_scope (sk_template_spec, NULL);
589 note_template_header (1);
590 return check_specialization_scope ();
593 /* Called at then end of processing a declaration preceded by
597 end_specialization (void)
600 reset_specialization ();
603 /* Any template <>'s that we have seen thus far are not referring to a
604 function specialization. */
607 reset_specialization (void)
609 processing_specialization = 0;
610 template_header_count = 0;
613 /* We've just seen a template header. If SPECIALIZATION is nonzero,
614 it was of the form template <>. */
617 note_template_header (int specialization)
619 processing_specialization = specialization;
620 template_header_count++;
623 /* We're beginning an explicit instantiation. */
626 begin_explicit_instantiation (void)
628 gcc_assert (!processing_explicit_instantiation);
629 processing_explicit_instantiation = true;
634 end_explicit_instantiation (void)
636 gcc_assert (processing_explicit_instantiation);
637 processing_explicit_instantiation = false;
640 /* An explicit specialization or partial specialization TMPL is being
641 declared. Check that the namespace in which the specialization is
642 occurring is permissible. Returns false iff it is invalid to
643 specialize TMPL in the current namespace. */
646 check_specialization_namespace (tree tmpl)
648 tree tpl_ns = decl_namespace_context (tmpl);
652 An explicit specialization shall be declared in the namespace of
653 which the template is a member, or, for member templates, in the
654 namespace of which the enclosing class or enclosing class
655 template is a member. An explicit specialization of a member
656 function, member class or static data member of a class template
657 shall be declared in the namespace of which the class template is
659 if (is_associated_namespace (current_namespace, tpl_ns))
660 /* Same or super-using namespace. */
664 pedwarn ("specialization of %qD in different namespace", tmpl);
665 pedwarn (" from definition of %q+#D", tmpl);
670 /* SPEC is an explicit instantiation. Check that it is valid to
671 perform this explicit instantiation in the current namespace. */
674 check_explicit_instantiation_namespace (tree spec)
678 /* DR 275: An explicit instantiation shall appear in an enclosing
679 namespace of its template. */
680 ns = decl_namespace_context (spec);
681 if (!is_ancestor (current_namespace, ns))
682 pedwarn ("explicit instantiation of %qD in namespace %qD "
683 "(which does not enclose namespace %qD)",
684 spec, current_namespace, ns);
687 /* The TYPE is being declared. If it is a template type, that means it
688 is a partial specialization. Do appropriate error-checking. */
691 maybe_process_partial_specialization (tree type)
695 if (type == error_mark_node)
696 return error_mark_node;
698 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
700 error ("name of class shadows template template parameter %qD",
702 return error_mark_node;
705 context = TYPE_CONTEXT (type);
707 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
709 /* This is for ordinary explicit specialization and partial
710 specialization of a template class such as:
712 template <> class C<int>;
716 template <class T> class C<T*>;
718 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
720 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
721 && !COMPLETE_TYPE_P (type))
723 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
724 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
725 if (processing_template_decl)
726 push_template_decl (TYPE_MAIN_DECL (type));
728 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
729 error ("specialization of %qT after instantiation", type);
731 else if (CLASS_TYPE_P (type)
732 && !CLASSTYPE_USE_TEMPLATE (type)
733 && CLASSTYPE_TEMPLATE_INFO (type)
734 && context && CLASS_TYPE_P (context)
735 && CLASSTYPE_TEMPLATE_INFO (context))
737 /* This is for an explicit specialization of member class
738 template according to [temp.expl.spec/18]:
740 template <> template <class U> class C<int>::D;
742 The context `C<int>' must be an implicit instantiation.
743 Otherwise this is just a member class template declared
746 template <> class C<int> { template <class U> class D; };
747 template <> template <class U> class C<int>::D;
749 In the first case, `C<int>::D' is a specialization of `C<T>::D'
750 while in the second case, `C<int>::D' is a primary template
751 and `C<T>::D' may not exist. */
753 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
754 && !COMPLETE_TYPE_P (type))
758 if (current_namespace
759 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
761 pedwarn ("specializing %q#T in different namespace", type);
762 pedwarn (" from definition of %q+#D",
763 CLASSTYPE_TI_TEMPLATE (type));
766 /* Check for invalid specialization after instantiation:
768 template <> template <> class C<int>::D<int>;
769 template <> template <class U> class C<int>::D; */
771 for (t = DECL_TEMPLATE_INSTANTIATIONS
772 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
773 t; t = TREE_CHAIN (t))
774 if (TREE_VALUE (t) != type
775 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
776 error ("specialization %qT after instantiation %qT",
777 type, TREE_VALUE (t));
779 /* Mark TYPE as a specialization. And as a result, we only
780 have one level of template argument for the innermost
782 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
783 CLASSTYPE_TI_ARGS (type)
784 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
787 else if (processing_specialization)
789 error ("explicit specialization of non-template %qT", type);
790 return error_mark_node;
796 /* Returns nonzero if we can optimize the retrieval of specializations
797 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
798 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
801 optimize_specialization_lookup_p (tree tmpl)
803 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
804 && DECL_CLASS_SCOPE_P (tmpl)
805 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
807 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
808 /* The optimized lookup depends on the fact that the
809 template arguments for the member function template apply
810 purely to the containing class, which is not true if the
811 containing class is an explicit or partial
813 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
814 && !DECL_MEMBER_TEMPLATE_P (tmpl)
815 && !DECL_CONV_FN_P (tmpl)
816 /* It is possible to have a template that is not a member
817 template and is not a member of a template class:
819 template <typename T>
820 struct S { friend A::f(); };
822 Here, the friend function is a template, but the context does
823 not have template information. The optimized lookup relies
824 on having ARGS be the template arguments for both the class
825 and the function template. */
826 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
829 /* Retrieve the specialization (in the sense of [temp.spec] - a
830 specialization is either an instantiation or an explicit
831 specialization) of TMPL for the given template ARGS. If there is
832 no such specialization, return NULL_TREE. The ARGS are a vector of
833 arguments, or a vector of vectors of arguments, in the case of
834 templates with more than one level of parameters.
836 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
837 then we search for a partial specialization matching ARGS. This
838 parameter is ignored if TMPL is not a class template. */
841 retrieve_specialization (tree tmpl, tree args,
842 bool class_specializations_p)
844 if (args == error_mark_node)
847 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
849 /* There should be as many levels of arguments as there are
850 levels of parameters. */
851 gcc_assert (TMPL_ARGS_DEPTH (args)
852 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
854 if (optimize_specialization_lookup_p (tmpl))
857 tree class_specialization;
858 VEC(tree,gc) *methods;
862 /* The template arguments actually apply to the containing
863 class. Find the class specialization with those
865 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
867 = retrieve_specialization (class_template, args,
868 /*class_specializations_p=*/false);
869 if (!class_specialization)
871 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
872 for the specialization. */
873 idx = class_method_index_for_fn (class_specialization, tmpl);
876 /* Iterate through the methods with the indicated name, looking
877 for the one that has an instance of TMPL. */
878 methods = CLASSTYPE_METHOD_VEC (class_specialization);
879 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
881 tree fn = OVL_CURRENT (fns);
882 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
892 /* Class templates store their instantiations on the
893 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
894 DECL_TEMPLATE_SPECIALIZATIONS list. */
895 if (!class_specializations_p
896 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
897 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
899 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
901 /* Iterate through the list until we find a matching template. */
902 while (*sp != NULL_TREE)
906 if (comp_template_args (TREE_PURPOSE (spec), args))
908 /* Use the move-to-front heuristic to speed up future
912 *sp = TREE_CHAIN (*sp);
913 TREE_CHAIN (spec) = *head;
916 return TREE_VALUE (spec);
918 sp = &TREE_CHAIN (spec);
925 /* Like retrieve_specialization, but for local declarations. */
928 retrieve_local_specialization (tree tmpl)
930 tree spec = (tree) htab_find_with_hash (local_specializations, tmpl,
931 htab_hash_pointer (tmpl));
932 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
935 /* Returns nonzero iff DECL is a specialization of TMPL. */
938 is_specialization_of (tree decl, tree tmpl)
942 if (TREE_CODE (decl) == FUNCTION_DECL)
946 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
952 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
954 for (t = TREE_TYPE (decl);
956 t = CLASSTYPE_USE_TEMPLATE (t)
957 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
958 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
965 /* Returns nonzero iff DECL is a specialization of friend declaration
966 FRIEND according to [temp.friend]. */
969 is_specialization_of_friend (tree decl, tree friend)
971 bool need_template = true;
974 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
975 || TREE_CODE (decl) == TYPE_DECL);
977 /* For [temp.friend/6] when FRIEND is an ordinary member function
978 of a template class, we want to check if DECL is a specialization
980 if (TREE_CODE (friend) == FUNCTION_DECL
981 && DECL_TEMPLATE_INFO (friend)
982 && !DECL_USE_TEMPLATE (friend))
984 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
985 friend = DECL_TI_TEMPLATE (friend);
986 need_template = false;
988 else if (TREE_CODE (friend) == TEMPLATE_DECL
989 && !PRIMARY_TEMPLATE_P (friend))
990 need_template = false;
992 /* There is nothing to do if this is not a template friend. */
993 if (TREE_CODE (friend) != TEMPLATE_DECL)
996 if (is_specialization_of (decl, friend))
1000 A member of a class template may be declared to be a friend of a
1001 non-template class. In this case, the corresponding member of
1002 every specialization of the class template is a friend of the
1003 class granting friendship.
1005 For example, given a template friend declaration
1007 template <class T> friend void A<T>::f();
1009 the member function below is considered a friend
1011 template <> struct A<int> {
1015 For this type of template friend, TEMPLATE_DEPTH below will be
1016 nonzero. To determine if DECL is a friend of FRIEND, we first
1017 check if the enclosing class is a specialization of another. */
1019 template_depth = template_class_depth (DECL_CONTEXT (friend));
1021 && DECL_CLASS_SCOPE_P (decl)
1022 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1023 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1025 /* Next, we check the members themselves. In order to handle
1026 a few tricky cases, such as when FRIEND's are
1028 template <class T> friend void A<T>::g(T t);
1029 template <class T> template <T t> friend void A<T>::h();
1033 void A<int>::g(int);
1034 template <int> void A<int>::h();
1036 we need to figure out ARGS, the template arguments from
1037 the context of DECL. This is required for template substitution
1038 of `T' in the function parameter of `g' and template parameter
1039 of `h' in the above examples. Here ARGS corresponds to `int'. */
1041 tree context = DECL_CONTEXT (decl);
1042 tree args = NULL_TREE;
1043 int current_depth = 0;
1045 while (current_depth < template_depth)
1047 if (CLASSTYPE_TEMPLATE_INFO (context))
1049 if (current_depth == 0)
1050 args = TYPE_TI_ARGS (context);
1052 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1055 context = TYPE_CONTEXT (context);
1058 if (TREE_CODE (decl) == FUNCTION_DECL)
1063 tree friend_args_type;
1064 tree decl_args_type;
1066 /* Make sure that both DECL and FRIEND are templates or
1068 is_template = DECL_TEMPLATE_INFO (decl)
1069 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1070 if (need_template ^ is_template)
1072 else if (is_template)
1074 /* If both are templates, check template parameter list. */
1076 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1078 if (!comp_template_parms
1079 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1083 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1086 decl_type = TREE_TYPE (decl);
1088 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1089 tf_none, NULL_TREE);
1090 if (friend_type == error_mark_node)
1093 /* Check if return types match. */
1094 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1097 /* Check if function parameter types match, ignoring the
1098 `this' parameter. */
1099 friend_args_type = TYPE_ARG_TYPES (friend_type);
1100 decl_args_type = TYPE_ARG_TYPES (decl_type);
1101 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1102 friend_args_type = TREE_CHAIN (friend_args_type);
1103 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1104 decl_args_type = TREE_CHAIN (decl_args_type);
1106 return compparms (decl_args_type, friend_args_type);
1110 /* DECL is a TYPE_DECL */
1112 tree decl_type = TREE_TYPE (decl);
1114 /* Make sure that both DECL and FRIEND are templates or
1117 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1118 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1120 if (need_template ^ is_template)
1122 else if (is_template)
1125 /* If both are templates, check the name of the two
1126 TEMPLATE_DECL's first because is_friend didn't. */
1127 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1128 != DECL_NAME (friend))
1131 /* Now check template parameter list. */
1133 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1135 return comp_template_parms
1136 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1140 return (DECL_NAME (decl)
1141 == DECL_NAME (friend));
1147 /* Register the specialization SPEC as a specialization of TMPL with
1148 the indicated ARGS. IS_FRIEND indicates whether the specialization
1149 is actually just a friend declaration. Returns SPEC, or an
1150 equivalent prior declaration, if available. */
1153 register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1157 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1159 if (TREE_CODE (spec) == FUNCTION_DECL
1160 && uses_template_parms (DECL_TI_ARGS (spec)))
1161 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1162 register it; we want the corresponding TEMPLATE_DECL instead.
1163 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1164 the more obvious `uses_template_parms (spec)' to avoid problems
1165 with default function arguments. In particular, given
1166 something like this:
1168 template <class T> void f(T t1, T t = T())
1170 the default argument expression is not substituted for in an
1171 instantiation unless and until it is actually needed. */
1174 fn = retrieve_specialization (tmpl, args,
1175 /*class_specializations_p=*/false);
1176 /* We can sometimes try to re-register a specialization that we've
1177 already got. In particular, regenerate_decl_from_template calls
1178 duplicate_decls which will update the specialization list. But,
1179 we'll still get called again here anyhow. It's more convenient
1180 to simply allow this than to try to prevent it. */
1183 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1185 if (DECL_TEMPLATE_INSTANTIATION (fn))
1188 || DECL_EXPLICIT_INSTANTIATION (fn))
1190 error ("specialization of %qD after instantiation",
1192 return error_mark_node;
1197 /* This situation should occur only if the first
1198 specialization is an implicit instantiation, the
1199 second is an explicit specialization, and the
1200 implicit instantiation has not yet been used. That
1201 situation can occur if we have implicitly
1202 instantiated a member function and then specialized
1205 We can also wind up here if a friend declaration that
1206 looked like an instantiation turns out to be a
1209 template <class T> void foo(T);
1210 class S { friend void foo<>(int) };
1211 template <> void foo(int);
1213 We transform the existing DECL in place so that any
1214 pointers to it become pointers to the updated
1217 If there was a definition for the template, but not
1218 for the specialization, we want this to look as if
1219 there were no definition, and vice versa. */
1220 DECL_INITIAL (fn) = NULL_TREE;
1221 duplicate_decls (spec, fn, is_friend);
1222 /* The call to duplicate_decls will have applied
1225 An explicit specialization of a function template
1226 is inline only if it is explicitly declared to be,
1227 and independently of whether its function template
1230 to the primary function; now copy the inline bits to
1231 the various clones. */
1232 FOR_EACH_CLONE (clone, fn)
1234 DECL_DECLARED_INLINE_P (clone)
1235 = DECL_DECLARED_INLINE_P (fn);
1239 check_specialization_namespace (fn);
1244 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1246 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1247 /* Dup decl failed, but this is a new definition. Set the
1248 line number so any errors match this new
1250 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1256 /* A specialization must be declared in the same namespace as the
1257 template it is specializing. */
1258 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1259 && !check_specialization_namespace (tmpl))
1260 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1262 if (!optimize_specialization_lookup_p (tmpl))
1263 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1264 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1269 /* Unregister the specialization SPEC as a specialization of TMPL.
1270 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1271 if the SPEC was listed as a specialization of TMPL. */
1274 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1278 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1280 s = &TREE_CHAIN (*s))
1281 if (TREE_VALUE (*s) == spec)
1284 *s = TREE_CHAIN (*s);
1286 TREE_VALUE (*s) = new_spec;
1293 /* Compare an entry in the local specializations hash table P1 (which
1294 is really a pointer to a TREE_LIST) with P2 (which is really a
1298 eq_local_specializations (const void *p1, const void *p2)
1300 return TREE_VALUE ((tree) p1) == (tree) p2;
1303 /* Hash P1, an entry in the local specializations table. */
1306 hash_local_specialization (const void* p1)
1308 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1311 /* Like register_specialization, but for local declarations. We are
1312 registering SPEC, an instantiation of TMPL. */
1315 register_local_specialization (tree spec, tree tmpl)
1319 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1320 htab_hash_pointer (tmpl), INSERT);
1321 *slot = build_tree_list (spec, tmpl);
1324 /* TYPE is a class type. Returns true if TYPE is an explicitly
1325 specialized class. */
1328 explicit_class_specialization_p (tree type)
1330 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1332 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1335 /* Print the list of candidate FNS in an error message. */
1338 print_candidates (tree fns)
1342 const char *str = "candidates are:";
1344 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1348 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1349 error ("%s %+#D", str, OVL_CURRENT (f));
1354 /* Returns the template (one of the functions given by TEMPLATE_ID)
1355 which can be specialized to match the indicated DECL with the
1356 explicit template args given in TEMPLATE_ID. The DECL may be
1357 NULL_TREE if none is available. In that case, the functions in
1358 TEMPLATE_ID are non-members.
1360 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1361 specialization of a member template.
1363 The TEMPLATE_COUNT is the number of references to qualifying
1364 template classes that appeared in the name of the function. See
1365 check_explicit_specialization for a more accurate description.
1367 TSK indicates what kind of template declaration (if any) is being
1368 declared. TSK_TEMPLATE indicates that the declaration given by
1369 DECL, though a FUNCTION_DECL, has template parameters, and is
1370 therefore a template function.
1372 The template args (those explicitly specified and those deduced)
1373 are output in a newly created vector *TARGS_OUT.
1375 If it is impossible to determine the result, an error message is
1376 issued. The error_mark_node is returned to indicate failure. */
1379 determine_specialization (tree template_id,
1382 int need_member_template,
1388 tree explicit_targs;
1389 tree candidates = NULL_TREE;
1390 /* A TREE_LIST of templates of which DECL may be a specialization.
1391 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1392 corresponding TREE_PURPOSE is the set of template arguments that,
1393 when used to instantiate the template, would produce a function
1394 with the signature of DECL. */
1395 tree templates = NULL_TREE;
1397 struct cp_binding_level *b;
1399 *targs_out = NULL_TREE;
1401 if (template_id == error_mark_node || decl == error_mark_node)
1402 return error_mark_node;
1404 fns = TREE_OPERAND (template_id, 0);
1405 explicit_targs = TREE_OPERAND (template_id, 1);
1407 if (fns == error_mark_node)
1408 return error_mark_node;
1410 /* Check for baselinks. */
1411 if (BASELINK_P (fns))
1412 fns = BASELINK_FUNCTIONS (fns);
1414 if (!is_overloaded_fn (fns))
1416 error ("%qD is not a function template", fns);
1417 return error_mark_node;
1420 /* Count the number of template headers specified for this
1423 for (b = current_binding_level;
1424 b->kind == sk_template_parms;
1428 for (; fns; fns = OVL_NEXT (fns))
1430 tree fn = OVL_CURRENT (fns);
1432 if (TREE_CODE (fn) == TEMPLATE_DECL)
1434 tree decl_arg_types;
1437 /* In case of explicit specialization, we need to check if
1438 the number of template headers appearing in the specialization
1439 is correct. This is usually done in check_explicit_specialization,
1440 but the check done there cannot be exhaustive when specializing
1441 member functions. Consider the following code:
1443 template <> void A<int>::f(int);
1444 template <> template <> void A<int>::f(int);
1446 Assuming that A<int> is not itself an explicit specialization
1447 already, the first line specializes "f" which is a non-template
1448 member function, whilst the second line specializes "f" which
1449 is a template member function. So both lines are syntactically
1450 correct, and check_explicit_specialization does not reject
1453 Here, we can do better, as we are matching the specialization
1454 against the declarations. We count the number of template
1455 headers, and we check if they match TEMPLATE_COUNT + 1
1456 (TEMPLATE_COUNT is the number of qualifying template classes,
1457 plus there must be another header for the member template
1460 Notice that if header_count is zero, this is not a
1461 specialization but rather a template instantiation, so there
1462 is no check we can perform here. */
1463 if (header_count && header_count != template_count + 1)
1466 /* Check that the number of template arguments at the
1467 innermost level for DECL is the same as for FN. */
1468 if (current_binding_level->kind == sk_template_parms
1469 && !current_binding_level->explicit_spec_p
1470 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1471 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1472 (current_template_parms))))
1475 /* DECL might be a specialization of FN. */
1476 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1477 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1479 /* For a non-static member function, we need to make sure
1480 that the const qualification is the same. Since
1481 get_bindings does not try to merge the "this" parameter,
1482 we must do the comparison explicitly. */
1483 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1484 && !same_type_p (TREE_VALUE (fn_arg_types),
1485 TREE_VALUE (decl_arg_types)))
1488 /* Skip the "this" parameter and, for constructors of
1489 classes with virtual bases, the VTT parameter. A
1490 full specialization of a constructor will have a VTT
1491 parameter, but a template never will. */
1493 = skip_artificial_parms_for (decl, decl_arg_types);
1495 = skip_artificial_parms_for (fn, fn_arg_types);
1497 /* Check that the number of function parameters matches.
1499 template <class T> void f(int i = 0);
1500 template <> void f<int>();
1501 The specialization f<int> is invalid but is not caught
1502 by get_bindings below. */
1503 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1506 /* Function templates cannot be specializations; there are
1507 no partial specializations of functions. Therefore, if
1508 the type of DECL does not match FN, there is no
1510 if (tsk == tsk_template)
1512 if (compparms (fn_arg_types, decl_arg_types))
1513 candidates = tree_cons (NULL_TREE, fn, candidates);
1517 /* See whether this function might be a specialization of this
1519 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1522 /* We cannot deduce template arguments that when used to
1523 specialize TMPL will produce DECL. */
1526 /* Save this template, and the arguments deduced. */
1527 templates = tree_cons (targs, fn, templates);
1529 else if (need_member_template)
1530 /* FN is an ordinary member function, and we need a
1531 specialization of a member template. */
1533 else if (TREE_CODE (fn) != FUNCTION_DECL)
1534 /* We can get IDENTIFIER_NODEs here in certain erroneous
1537 else if (!DECL_FUNCTION_MEMBER_P (fn))
1538 /* This is just an ordinary non-member function. Nothing can
1539 be a specialization of that. */
1541 else if (DECL_ARTIFICIAL (fn))
1542 /* Cannot specialize functions that are created implicitly. */
1546 tree decl_arg_types;
1548 /* This is an ordinary member function. However, since
1549 we're here, we can assume it's enclosing class is a
1550 template class. For example,
1552 template <typename T> struct S { void f(); };
1553 template <> void S<int>::f() {}
1555 Here, S<int>::f is a non-template, but S<int> is a
1556 template class. If FN has the same type as DECL, we
1557 might be in business. */
1559 if (!DECL_TEMPLATE_INFO (fn))
1560 /* Its enclosing class is an explicit specialization
1561 of a template class. This is not a candidate. */
1564 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1565 TREE_TYPE (TREE_TYPE (fn))))
1566 /* The return types differ. */
1569 /* Adjust the type of DECL in case FN is a static member. */
1570 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1571 if (DECL_STATIC_FUNCTION_P (fn)
1572 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1573 decl_arg_types = TREE_CHAIN (decl_arg_types);
1575 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1578 candidates = tree_cons (NULL_TREE, fn, candidates);
1582 if (templates && TREE_CHAIN (templates))
1588 It is possible for a specialization with a given function
1589 signature to be instantiated from more than one function
1590 template. In such cases, explicit specification of the
1591 template arguments must be used to uniquely identify the
1592 function template specialization being specialized.
1594 Note that here, there's no suggestion that we're supposed to
1595 determine which of the candidate templates is most
1596 specialized. However, we, also have:
1600 Partial ordering of overloaded function template
1601 declarations is used in the following contexts to select
1602 the function template to which a function template
1603 specialization refers:
1605 -- when an explicit specialization refers to a function
1608 So, we do use the partial ordering rules, at least for now.
1609 This extension can only serve to make invalid programs valid,
1610 so it's safe. And, there is strong anecdotal evidence that
1611 the committee intended the partial ordering rules to apply;
1612 the EDG front end has that behavior, and John Spicer claims
1613 that the committee simply forgot to delete the wording in
1614 [temp.expl.spec]. */
1615 tree tmpl = most_specialized_instantiation (templates);
1616 if (tmpl != error_mark_node)
1619 TREE_CHAIN (templates) = NULL_TREE;
1623 if (templates == NULL_TREE && candidates == NULL_TREE)
1625 error ("template-id %qD for %q+D does not match any template "
1626 "declaration", template_id, decl);
1627 return error_mark_node;
1629 else if ((templates && TREE_CHAIN (templates))
1630 || (candidates && TREE_CHAIN (candidates))
1631 || (templates && candidates))
1633 error ("ambiguous template specialization %qD for %q+D",
1635 chainon (candidates, templates);
1636 print_candidates (candidates);
1637 return error_mark_node;
1640 /* We have one, and exactly one, match. */
1643 tree fn = TREE_VALUE (candidates);
1644 /* DECL is a re-declaration of a template function. */
1645 if (TREE_CODE (fn) == TEMPLATE_DECL)
1647 /* It was a specialization of an ordinary member function in a
1649 *targs_out = copy_node (DECL_TI_ARGS (fn));
1650 return DECL_TI_TEMPLATE (fn);
1653 /* It was a specialization of a template. */
1654 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1655 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1657 *targs_out = copy_node (targs);
1658 SET_TMPL_ARGS_LEVEL (*targs_out,
1659 TMPL_ARGS_DEPTH (*targs_out),
1660 TREE_PURPOSE (templates));
1663 *targs_out = TREE_PURPOSE (templates);
1664 return TREE_VALUE (templates);
1667 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1668 but with the default argument values filled in from those in the
1672 copy_default_args_to_explicit_spec_1 (tree spec_types,
1675 tree new_spec_types;
1680 if (spec_types == void_list_node)
1681 return void_list_node;
1683 /* Substitute into the rest of the list. */
1685 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1686 TREE_CHAIN (tmpl_types));
1688 /* Add the default argument for this parameter. */
1689 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1690 TREE_VALUE (spec_types),
1694 /* DECL is an explicit specialization. Replicate default arguments
1695 from the template it specializes. (That way, code like:
1697 template <class T> void f(T = 3);
1698 template <> void f(double);
1701 works, as required.) An alternative approach would be to look up
1702 the correct default arguments at the call-site, but this approach
1703 is consistent with how implicit instantiations are handled. */
1706 copy_default_args_to_explicit_spec (tree decl)
1711 tree new_spec_types;
1715 tree object_type = NULL_TREE;
1716 tree in_charge = NULL_TREE;
1717 tree vtt = NULL_TREE;
1719 /* See if there's anything we need to do. */
1720 tmpl = DECL_TI_TEMPLATE (decl);
1721 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1722 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1723 if (TREE_PURPOSE (t))
1728 old_type = TREE_TYPE (decl);
1729 spec_types = TYPE_ARG_TYPES (old_type);
1731 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1733 /* Remove the this pointer, but remember the object's type for
1735 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1736 spec_types = TREE_CHAIN (spec_types);
1737 tmpl_types = TREE_CHAIN (tmpl_types);
1739 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1741 /* DECL may contain more parameters than TMPL due to the extra
1742 in-charge parameter in constructors and destructors. */
1743 in_charge = spec_types;
1744 spec_types = TREE_CHAIN (spec_types);
1746 if (DECL_HAS_VTT_PARM_P (decl))
1749 spec_types = TREE_CHAIN (spec_types);
1753 /* Compute the merged default arguments. */
1755 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1757 /* Compute the new FUNCTION_TYPE. */
1761 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1766 /* Put the in-charge parameter back. */
1767 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1768 TREE_VALUE (in_charge),
1771 new_type = build_method_type_directly (object_type,
1772 TREE_TYPE (old_type),
1776 new_type = build_function_type (TREE_TYPE (old_type),
1778 new_type = cp_build_type_attribute_variant (new_type,
1779 TYPE_ATTRIBUTES (old_type));
1780 new_type = build_exception_variant (new_type,
1781 TYPE_RAISES_EXCEPTIONS (old_type));
1782 TREE_TYPE (decl) = new_type;
1785 /* Check to see if the function just declared, as indicated in
1786 DECLARATOR, and in DECL, is a specialization of a function
1787 template. We may also discover that the declaration is an explicit
1788 instantiation at this point.
1790 Returns DECL, or an equivalent declaration that should be used
1791 instead if all goes well. Issues an error message if something is
1792 amiss. Returns error_mark_node if the error is not easily
1795 FLAGS is a bitmask consisting of the following flags:
1797 2: The function has a definition.
1798 4: The function is a friend.
1800 The TEMPLATE_COUNT is the number of references to qualifying
1801 template classes that appeared in the name of the function. For
1804 template <class T> struct S { void f(); };
1807 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1808 classes are not counted in the TEMPLATE_COUNT, so that in
1810 template <class T> struct S {};
1811 template <> struct S<int> { void f(); }
1812 template <> void S<int>::f();
1814 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1815 invalid; there should be no template <>.)
1817 If the function is a specialization, it is marked as such via
1818 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1819 is set up correctly, and it is added to the list of specializations
1820 for that template. */
1823 check_explicit_specialization (tree declarator,
1828 int have_def = flags & 2;
1829 int is_friend = flags & 4;
1830 int specialization = 0;
1831 int explicit_instantiation = 0;
1832 int member_specialization = 0;
1833 tree ctype = DECL_CLASS_CONTEXT (decl);
1834 tree dname = DECL_NAME (decl);
1839 if (!processing_specialization)
1842 tsk = tsk_excessive_parms;
1845 tsk = current_tmpl_spec_kind (template_count);
1850 if (processing_specialization)
1853 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1855 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1858 /* This could be something like:
1860 template <class T> void f(T);
1861 class S { friend void f<>(int); } */
1865 /* This case handles bogus declarations like template <>
1866 template <class T> void f<int>(); */
1868 error ("template-id %qD in declaration of primary template",
1875 case tsk_invalid_member_spec:
1876 /* The error has already been reported in
1877 check_specialization_scope. */
1878 return error_mark_node;
1880 case tsk_invalid_expl_inst:
1881 error ("template parameter list used in explicit instantiation");
1887 error ("definition provided for explicit instantiation");
1889 explicit_instantiation = 1;
1892 case tsk_excessive_parms:
1893 case tsk_insufficient_parms:
1894 if (tsk == tsk_excessive_parms)
1895 error ("too many template parameter lists in declaration of %qD",
1897 else if (template_header_count)
1898 error("too few template parameter lists in declaration of %qD", decl);
1900 error("explicit specialization of %qD must be introduced by "
1901 "%<template <>%>", decl);
1905 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1907 member_specialization = 1;
1913 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1915 /* This case handles bogus declarations like template <>
1916 template <class T> void f<int>(); */
1918 if (uses_template_parms (declarator))
1919 error ("function template partial specialization %qD "
1920 "is not allowed", declarator);
1922 error ("template-id %qD in declaration of primary template",
1927 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1928 /* This is a specialization of a member template, without
1929 specialization the containing class. Something like:
1931 template <class T> struct S {
1932 template <class U> void f (U);
1934 template <> template <class U> void S<int>::f(U) {}
1936 That's a specialization -- but of the entire template. */
1944 if (specialization || member_specialization)
1946 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1947 for (; t; t = TREE_CHAIN (t))
1948 if (TREE_PURPOSE (t))
1951 ("default argument specified in explicit specialization");
1956 if (specialization || member_specialization || explicit_instantiation)
1958 tree tmpl = NULL_TREE;
1959 tree targs = NULL_TREE;
1961 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1962 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1966 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
1971 /* If there is no class context, the explicit instantiation
1972 must be at namespace scope. */
1973 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
1975 /* Find the namespace binding, using the declaration
1977 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
1979 if (!fns || !is_overloaded_fn (fns))
1981 error ("%qD is not a template function", dname);
1982 fns = error_mark_node;
1986 tree fn = OVL_CURRENT (fns);
1987 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
1988 CP_DECL_CONTEXT (fn)))
1989 error ("%qD is not declared in %qD",
1990 decl, current_namespace);
1994 declarator = lookup_template_function (fns, NULL_TREE);
1997 if (declarator == error_mark_node)
1998 return error_mark_node;
2000 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2002 if (!explicit_instantiation)
2003 /* A specialization in class scope. This is invalid,
2004 but the error will already have been flagged by
2005 check_specialization_scope. */
2006 return error_mark_node;
2009 /* It's not valid to write an explicit instantiation in
2012 class C { template void f(); }
2014 This case is caught by the parser. However, on
2017 template class C { void f(); };
2019 (which is invalid) we can get here. The error will be
2026 else if (ctype != NULL_TREE
2027 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2030 /* Find the list of functions in ctype that have the same
2031 name as the declared function. */
2032 tree name = TREE_OPERAND (declarator, 0);
2033 tree fns = NULL_TREE;
2036 if (constructor_name_p (name, ctype))
2038 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2040 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
2041 : !CLASSTYPE_DESTRUCTORS (ctype))
2043 /* From [temp.expl.spec]:
2045 If such an explicit specialization for the member
2046 of a class template names an implicitly-declared
2047 special member function (clause _special_), the
2048 program is ill-formed.
2050 Similar language is found in [temp.explicit]. */
2051 error ("specialization of implicitly-declared special member function");
2052 return error_mark_node;
2055 name = is_constructor ? ctor_identifier : dtor_identifier;
2058 if (!DECL_CONV_FN_P (decl))
2060 idx = lookup_fnfields_1 (ctype, name);
2062 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2066 VEC(tree,gc) *methods;
2069 /* For a type-conversion operator, we cannot do a
2070 name-based lookup. We might be looking for `operator
2071 int' which will be a specialization of `operator T'.
2072 So, we find *all* the conversion operators, and then
2073 select from them. */
2076 methods = CLASSTYPE_METHOD_VEC (ctype);
2078 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2079 VEC_iterate (tree, methods, idx, ovl);
2082 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2083 /* There are no more conversion functions. */
2086 /* Glue all these conversion functions together
2087 with those we already have. */
2088 for (; ovl; ovl = OVL_NEXT (ovl))
2089 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2093 if (fns == NULL_TREE)
2095 error ("no member function %qD declared in %qT", name, ctype);
2096 return error_mark_node;
2099 TREE_OPERAND (declarator, 0) = fns;
2102 /* Figure out what exactly is being specialized at this point.
2103 Note that for an explicit instantiation, even one for a
2104 member function, we cannot tell apriori whether the
2105 instantiation is for a member template, or just a member
2106 function of a template class. Even if a member template is
2107 being instantiated, the member template arguments may be
2108 elided if they can be deduced from the rest of the
2110 tmpl = determine_specialization (declarator, decl,
2112 member_specialization,
2116 if (!tmpl || tmpl == error_mark_node)
2117 /* We couldn't figure out what this declaration was
2119 return error_mark_node;
2122 tree gen_tmpl = most_general_template (tmpl);
2124 if (explicit_instantiation)
2126 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2127 is done by do_decl_instantiation later. */
2129 int arg_depth = TMPL_ARGS_DEPTH (targs);
2130 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2132 if (arg_depth > parm_depth)
2134 /* If TMPL is not the most general template (for
2135 example, if TMPL is a friend template that is
2136 injected into namespace scope), then there will
2137 be too many levels of TARGS. Remove some of them
2142 new_targs = make_tree_vec (parm_depth);
2143 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2144 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2145 = TREE_VEC_ELT (targs, i);
2149 return instantiate_template (tmpl, targs, tf_error);
2152 /* If we thought that the DECL was a member function, but it
2153 turns out to be specializing a static member function,
2154 make DECL a static member function as well. */
2155 if (DECL_STATIC_FUNCTION_P (tmpl)
2156 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2157 revert_static_member_fn (decl);
2159 /* If this is a specialization of a member template of a
2160 template class, we want to return the TEMPLATE_DECL, not
2161 the specialization of it. */
2162 if (tsk == tsk_template)
2164 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2165 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2168 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2169 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2170 = DECL_SOURCE_LOCATION (decl);
2171 /* We want to use the argument list specified in the
2172 definition, not in the original declaration. */
2173 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2174 = DECL_ARGUMENTS (decl);
2179 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2180 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2182 /* Inherit default function arguments from the template
2183 DECL is specializing. */
2184 copy_default_args_to_explicit_spec (decl);
2186 /* This specialization has the same protection as the
2187 template it specializes. */
2188 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2189 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2191 /* If DECL is a friend declaration, declared using an
2192 unqualified name, the namespace associated with DECL may
2193 have been set incorrectly. For example, in:
2195 template <typename T> void f(T);
2197 struct S { friend void f<int>(int); }
2200 we will have set the DECL_CONTEXT for the friend
2201 declaration to N, rather than to the global namespace. */
2202 if (DECL_NAMESPACE_SCOPE_P (decl))
2203 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2205 if (is_friend && !have_def)
2206 /* This is not really a declaration of a specialization.
2207 It's just the name of an instantiation. But, it's not
2208 a request for an instantiation, either. */
2209 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2210 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2211 /* This is indeed a specialization. In case of constructors
2212 and destructors, we need in-charge and not-in-charge
2213 versions in V3 ABI. */
2214 clone_function_decl (decl, /*update_method_vec_p=*/0);
2216 /* Register this specialization so that we can find it
2218 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2225 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2226 parameters. These are represented in the same format used for
2227 DECL_TEMPLATE_PARMS. */
2230 comp_template_parms (tree parms1, tree parms2)
2235 if (parms1 == parms2)
2238 for (p1 = parms1, p2 = parms2;
2239 p1 != NULL_TREE && p2 != NULL_TREE;
2240 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2242 tree t1 = TREE_VALUE (p1);
2243 tree t2 = TREE_VALUE (p2);
2246 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2247 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2249 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2252 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2254 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2255 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2257 /* If either of the template parameters are invalid, assume
2258 they match for the sake of error recovery. */
2259 if (parm1 == error_mark_node || parm2 == error_mark_node)
2262 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2265 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2267 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2272 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2273 /* One set of parameters has more parameters lists than the
2280 /* Complain if DECL shadows a template parameter.
2282 [temp.local]: A template-parameter shall not be redeclared within its
2283 scope (including nested scopes). */
2286 check_template_shadow (tree decl)
2290 /* If we're not in a template, we can't possibly shadow a template
2292 if (!current_template_parms)
2295 /* Figure out what we're shadowing. */
2296 if (TREE_CODE (decl) == OVERLOAD)
2297 decl = OVL_CURRENT (decl);
2298 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2300 /* If there's no previous binding for this name, we're not shadowing
2301 anything, let alone a template parameter. */
2305 /* If we're not shadowing a template parameter, we're done. Note
2306 that OLDDECL might be an OVERLOAD (or perhaps even an
2307 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2309 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2312 /* We check for decl != olddecl to avoid bogus errors for using a
2313 name inside a class. We check TPFI to avoid duplicate errors for
2314 inline member templates. */
2316 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2319 error ("declaration of %q+#D", decl);
2320 error (" shadows template parm %q+#D", olddecl);
2323 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2324 ORIG_LEVEL, DECL, and TYPE. */
2327 build_template_parm_index (int index,
2333 tree t = make_node (TEMPLATE_PARM_INDEX);
2334 TEMPLATE_PARM_IDX (t) = index;
2335 TEMPLATE_PARM_LEVEL (t) = level;
2336 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2337 TEMPLATE_PARM_DECL (t) = decl;
2338 TREE_TYPE (t) = type;
2339 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2340 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2341 TREE_READONLY (t) = TREE_READONLY (decl);
2346 /* Find the canonical type parameter for the given template type
2347 parameter. Returns the canonical type parameter, which may be TYPE
2348 if no such parameter existed. */
2350 canonical_type_parameter (tree type)
2353 int idx = TEMPLATE_TYPE_IDX (type);
2354 if (!canonical_template_parms)
2355 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
2357 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
2358 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
2360 list = VEC_index (tree, canonical_template_parms, idx);
2361 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
2362 list = TREE_CHAIN (list);
2365 return TREE_VALUE (list);
2368 VEC_replace(tree, canonical_template_parms, idx,
2369 tree_cons (NULL_TREE, type,
2370 VEC_index (tree, canonical_template_parms, idx)));
2375 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2376 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2377 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2378 new one is created. */
2381 reduce_template_parm_level (tree index, tree type, int levels)
2383 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2384 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2385 != TEMPLATE_PARM_LEVEL (index) - levels))
2387 tree orig_decl = TEMPLATE_PARM_DECL (index);
2390 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2391 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2392 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2393 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2394 DECL_ARTIFICIAL (decl) = 1;
2395 SET_DECL_TEMPLATE_PARM_P (decl);
2397 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2398 TEMPLATE_PARM_LEVEL (index) - levels,
2399 TEMPLATE_PARM_ORIG_LEVEL (index),
2401 TEMPLATE_PARM_DESCENDANTS (index) = t;
2403 /* Template template parameters need this. */
2404 if (TREE_CODE (decl) != CONST_DECL)
2405 DECL_TEMPLATE_PARMS (decl)
2406 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2409 return TEMPLATE_PARM_DESCENDANTS (index);
2412 /* Process information from new template parameter PARM and append it to the
2413 LIST being built. This new parameter is a non-type parameter iff
2414 IS_NON_TYPE is true. */
2417 process_template_parm (tree list, tree parm, bool is_non_type)
2424 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2425 defval = TREE_PURPOSE (parm);
2429 tree p = tree_last (list);
2431 if (p && TREE_VALUE (p) != error_mark_node)
2434 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2435 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2437 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2447 parm = TREE_VALUE (parm);
2449 SET_DECL_TEMPLATE_PARM_P (parm);
2451 if (TREE_TYPE (parm) == error_mark_node)
2453 err_parm_list = build_tree_list (defval, parm);
2454 TREE_VALUE (err_parm_list) = error_mark_node;
2455 return chainon (list, err_parm_list);
2461 The top-level cv-qualifiers on the template-parameter are
2462 ignored when determining its type. */
2463 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2464 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2466 err_parm_list = build_tree_list (defval, parm);
2467 TREE_VALUE (err_parm_list) = error_mark_node;
2468 return chainon (list, err_parm_list);
2472 /* A template parameter is not modifiable. */
2473 TREE_CONSTANT (parm) = 1;
2474 TREE_INVARIANT (parm) = 1;
2475 TREE_READONLY (parm) = 1;
2476 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2477 TREE_CONSTANT (decl) = 1;
2478 TREE_INVARIANT (decl) = 1;
2479 TREE_READONLY (decl) = 1;
2480 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2481 = build_template_parm_index (idx, processing_template_decl,
2482 processing_template_decl,
2483 decl, TREE_TYPE (parm));
2488 parm = TREE_VALUE (TREE_VALUE (parm));
2490 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2492 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2493 /* This is for distinguishing between real templates and template
2494 template parameters */
2495 TREE_TYPE (parm) = t;
2496 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2501 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2502 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2503 decl = build_decl (TYPE_DECL, parm, t);
2506 TYPE_NAME (t) = decl;
2507 TYPE_STUB_DECL (t) = decl;
2509 TEMPLATE_TYPE_PARM_INDEX (t)
2510 = build_template_parm_index (idx, processing_template_decl,
2511 processing_template_decl,
2512 decl, TREE_TYPE (parm));
2513 TYPE_CANONICAL (t) = canonical_type_parameter (t);
2515 DECL_ARTIFICIAL (decl) = 1;
2516 SET_DECL_TEMPLATE_PARM_P (decl);
2518 parm = build_tree_list (defval, parm);
2519 return chainon (list, parm);
2522 /* The end of a template parameter list has been reached. Process the
2523 tree list into a parameter vector, converting each parameter into a more
2524 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2528 end_template_parm_list (tree parms)
2532 tree saved_parmlist = make_tree_vec (list_length (parms));
2534 current_template_parms
2535 = tree_cons (size_int (processing_template_decl),
2536 saved_parmlist, current_template_parms);
2538 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2540 next = TREE_CHAIN (parm);
2541 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2542 TREE_CHAIN (parm) = NULL_TREE;
2545 --processing_template_parmlist;
2547 return saved_parmlist;
2550 /* end_template_decl is called after a template declaration is seen. */
2553 end_template_decl (void)
2555 reset_specialization ();
2557 if (! processing_template_decl)
2560 /* This matches the pushlevel in begin_template_parm_list. */
2563 --processing_template_decl;
2564 current_template_parms = TREE_CHAIN (current_template_parms);
2567 /* Given a template argument vector containing the template PARMS.
2568 The innermost PARMS are given first. */
2571 current_template_args (void)
2574 tree args = NULL_TREE;
2575 int length = TMPL_PARMS_DEPTH (current_template_parms);
2578 /* If there is only one level of template parameters, we do not
2579 create a TREE_VEC of TREE_VECs. Instead, we return a single
2580 TREE_VEC containing the arguments. */
2582 args = make_tree_vec (length);
2584 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2586 tree a = copy_node (TREE_VALUE (header));
2589 TREE_TYPE (a) = NULL_TREE;
2590 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2592 tree t = TREE_VEC_ELT (a, i);
2594 /* T will be a list if we are called from within a
2595 begin/end_template_parm_list pair, but a vector directly
2596 if within a begin/end_member_template_processing pair. */
2597 if (TREE_CODE (t) == TREE_LIST)
2601 if (t != error_mark_node)
2603 if (TREE_CODE (t) == TYPE_DECL
2604 || TREE_CODE (t) == TEMPLATE_DECL)
2607 t = DECL_INITIAL (t);
2610 TREE_VEC_ELT (a, i) = t;
2615 TREE_VEC_ELT (args, --l) = a;
2623 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2624 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
2625 a member template. Used by push_template_decl below. */
2628 build_template_decl (tree decl, tree parms, bool member_template_p)
2630 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2631 DECL_TEMPLATE_PARMS (tmpl) = parms;
2632 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2633 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
2634 if (DECL_LANG_SPECIFIC (decl))
2636 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2637 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2638 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2639 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2640 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2641 if (DECL_OVERLOADED_OPERATOR_P (decl))
2642 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2643 DECL_OVERLOADED_OPERATOR_P (decl));
2649 struct template_parm_data
2651 /* The level of the template parameters we are currently
2655 /* The index of the specialization argument we are currently
2659 /* An array whose size is the number of template parameters. The
2660 elements are nonzero if the parameter has been used in any one
2661 of the arguments processed so far. */
2664 /* An array whose size is the number of template arguments. The
2665 elements are nonzero if the argument makes use of template
2666 parameters of this level. */
2667 int* arg_uses_template_parms;
2670 /* Subroutine of push_template_decl used to see if each template
2671 parameter in a partial specialization is used in the explicit
2672 argument list. If T is of the LEVEL given in DATA (which is
2673 treated as a template_parm_data*), then DATA->PARMS is marked
2677 mark_template_parm (tree t, void* data)
2681 struct template_parm_data* tpd = (struct template_parm_data*) data;
2683 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2685 level = TEMPLATE_PARM_LEVEL (t);
2686 idx = TEMPLATE_PARM_IDX (t);
2690 level = TEMPLATE_TYPE_LEVEL (t);
2691 idx = TEMPLATE_TYPE_IDX (t);
2694 if (level == tpd->level)
2696 tpd->parms[idx] = 1;
2697 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2700 /* Return zero so that for_each_template_parm will continue the
2701 traversal of the tree; we want to mark *every* template parm. */
2705 /* Process the partial specialization DECL. */
2708 process_partial_specialization (tree decl)
2710 tree type = TREE_TYPE (decl);
2711 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2712 tree specargs = CLASSTYPE_TI_ARGS (type);
2713 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2714 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2715 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2716 int nargs = TREE_VEC_LENGTH (inner_args);
2717 int ntparms = TREE_VEC_LENGTH (inner_parms);
2719 int did_error_intro = 0;
2720 struct template_parm_data tpd;
2721 struct template_parm_data tpd2;
2723 /* We check that each of the template parameters given in the
2724 partial specialization is used in the argument list to the
2725 specialization. For example:
2727 template <class T> struct S;
2728 template <class T> struct S<T*>;
2730 The second declaration is OK because `T*' uses the template
2731 parameter T, whereas
2733 template <class T> struct S<int>;
2735 is no good. Even trickier is:
2746 The S2<T> declaration is actually invalid; it is a
2747 full-specialization. Of course,
2750 struct S2<T (*)(U)>;
2752 or some such would have been OK. */
2753 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2754 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
2755 memset (tpd.parms, 0, sizeof (int) * ntparms);
2757 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
2758 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2759 for (i = 0; i < nargs; ++i)
2761 tpd.current_arg = i;
2762 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2763 &mark_template_parm,
2767 for (i = 0; i < ntparms; ++i)
2768 if (tpd.parms[i] == 0)
2770 /* One of the template parms was not used in the
2772 if (!did_error_intro)
2774 error ("template parameters not used in partial specialization:");
2775 did_error_intro = 1;
2778 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2781 /* [temp.class.spec]
2783 The argument list of the specialization shall not be identical to
2784 the implicit argument list of the primary template. */
2785 if (comp_template_args
2787 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2789 error ("partial specialization %qT does not specialize any template arguments", type);
2791 /* [temp.class.spec]
2793 A partially specialized non-type argument expression shall not
2794 involve template parameters of the partial specialization except
2795 when the argument expression is a simple identifier.
2797 The type of a template parameter corresponding to a specialized
2798 non-type argument shall not be dependent on a parameter of the
2800 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
2802 for (i = 0; i < nargs; ++i)
2804 tree arg = TREE_VEC_ELT (inner_args, i);
2805 if (/* These first two lines are the `non-type' bit. */
2807 && TREE_CODE (arg) != TEMPLATE_DECL
2808 /* This next line is the `argument expression is not just a
2809 simple identifier' condition and also the `specialized
2810 non-type argument' bit. */
2811 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2813 if (tpd.arg_uses_template_parms[i])
2814 error ("template argument %qE involves template parameter(s)", arg);
2817 /* Look at the corresponding template parameter,
2818 marking which template parameters its type depends
2821 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2826 /* We haven't yet initialized TPD2. Do so now. */
2827 tpd2.arg_uses_template_parms
2828 = (int *) alloca (sizeof (int) * nargs);
2829 /* The number of parameters here is the number in the
2830 main template, which, as checked in the assertion
2832 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
2834 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2837 /* Mark the template parameters. But this time, we're
2838 looking for the template parameters of the main
2839 template, not in the specialization. */
2840 tpd2.current_arg = i;
2841 tpd2.arg_uses_template_parms[i] = 0;
2842 memset (tpd2.parms, 0, sizeof (int) * nargs);
2843 for_each_template_parm (type,
2844 &mark_template_parm,
2848 if (tpd2.arg_uses_template_parms [i])
2850 /* The type depended on some template parameters.
2851 If they are fully specialized in the
2852 specialization, that's OK. */
2854 for (j = 0; j < nargs; ++j)
2855 if (tpd2.parms[j] != 0
2856 && tpd.arg_uses_template_parms [j])
2858 error ("type %qT of template argument %qE depends "
2859 "on template parameter(s)",
2869 if (retrieve_specialization (maintmpl, specargs,
2870 /*class_specializations_p=*/true))
2871 /* We've already got this specialization. */
2874 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2875 = tree_cons (specargs, inner_parms,
2876 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2877 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2881 /* Check that a template declaration's use of default arguments is not
2882 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2883 nonzero if DECL is the thing declared by a primary template.
2884 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2887 check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2890 int last_level_to_check;
2895 A default template-argument shall not be specified in a
2896 function template declaration or a function template definition, nor
2897 in the template-parameter-list of the definition of a member of a
2900 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2901 /* You can't have a function template declaration in a local
2902 scope, nor you can you define a member of a class template in a
2906 if (current_class_type
2907 && !TYPE_BEING_DEFINED (current_class_type)
2908 && DECL_LANG_SPECIFIC (decl)
2909 /* If this is either a friend defined in the scope of the class
2910 or a member function. */
2911 && (DECL_FUNCTION_MEMBER_P (decl)
2912 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2913 : DECL_FRIEND_CONTEXT (decl)
2914 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2916 /* And, if it was a member function, it really was defined in
2917 the scope of the class. */
2918 && (!DECL_FUNCTION_MEMBER_P (decl)
2919 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2920 /* We already checked these parameters when the template was
2921 declared, so there's no need to do it again now. This function
2922 was defined in class scope, but we're processing it's body now
2923 that the class is complete. */
2928 If a template-parameter has a default template-argument, all
2929 subsequent template-parameters shall have a default
2930 template-argument supplied. */
2931 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2933 tree inner_parms = TREE_VALUE (parm_level);
2934 int ntparms = TREE_VEC_LENGTH (inner_parms);
2935 int seen_def_arg_p = 0;
2938 for (i = 0; i < ntparms; ++i)
2940 tree parm = TREE_VEC_ELT (inner_parms, i);
2942 if (parm == error_mark_node)
2945 if (TREE_PURPOSE (parm))
2947 else if (seen_def_arg_p)
2949 error ("no default argument for %qD", TREE_VALUE (parm));
2950 /* For better subsequent error-recovery, we indicate that
2951 there should have been a default argument. */
2952 TREE_PURPOSE (parm) = error_mark_node;
2957 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2958 /* For an ordinary class template, default template arguments are
2959 allowed at the innermost level, e.g.:
2960 template <class T = int>
2962 but, in a partial specialization, they're not allowed even
2963 there, as we have in [temp.class.spec]:
2965 The template parameter list of a specialization shall not
2966 contain default template argument values.
2968 So, for a partial specialization, or for a function template,
2969 we look at all of them. */
2972 /* But, for a primary class template that is not a partial
2973 specialization we look at all template parameters except the
2975 parms = TREE_CHAIN (parms);
2977 /* Figure out what error message to issue. */
2978 if (TREE_CODE (decl) == FUNCTION_DECL)
2979 msg = "default template arguments may not be used in function templates";
2980 else if (is_partial)
2981 msg = "default template arguments may not be used in partial specializations";
2983 msg = "default argument for template parameter for class enclosing %qD";
2985 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2986 /* If we're inside a class definition, there's no need to
2987 examine the parameters to the class itself. On the one
2988 hand, they will be checked when the class is defined, and,
2989 on the other, default arguments are valid in things like:
2990 template <class T = double>
2991 struct S { template <class U> void f(U); };
2992 Here the default argument for `S' has no bearing on the
2993 declaration of `f'. */
2994 last_level_to_check = template_class_depth (current_class_type) + 1;
2996 /* Check everything. */
2997 last_level_to_check = 0;
2999 for (parm_level = parms;
3000 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
3001 parm_level = TREE_CHAIN (parm_level))
3003 tree inner_parms = TREE_VALUE (parm_level);
3007 ntparms = TREE_VEC_LENGTH (inner_parms);
3008 for (i = 0; i < ntparms; ++i)
3010 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
3013 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
3021 /* Clear out the default argument so that we are not
3023 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
3027 /* At this point, if we're still interested in issuing messages,
3028 they must apply to classes surrounding the object declared. */
3030 msg = "default argument for template parameter for class enclosing %qD";
3034 /* Worker for push_template_decl_real, called via
3035 for_each_template_parm. DATA is really an int, indicating the
3036 level of the parameters we are interested in. If T is a template
3037 parameter of that level, return nonzero. */
3040 template_parm_this_level_p (tree t, void* data)
3042 int this_level = *(int *)data;
3045 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3046 level = TEMPLATE_PARM_LEVEL (t);
3048 level = TEMPLATE_TYPE_LEVEL (t);
3049 return level == this_level;
3052 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3053 parameters given by current_template_args, or reuses a
3054 previously existing one, if appropriate. Returns the DECL, or an
3055 equivalent one, if it is replaced via a call to duplicate_decls.
3057 If IS_FRIEND is true, DECL is a friend declaration. */
3060 push_template_decl_real (tree decl, bool is_friend)
3068 int new_template_p = 0;
3069 /* True if the template is a member template, in the sense of
3071 bool member_template_p = false;
3073 if (decl == error_mark_node)
3076 /* See if this is a partial specialization. */
3077 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3078 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3079 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3081 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3085 /* For a friend, we want the context of the friend function, not
3086 the type of which it is a friend. */
3087 ctx = DECL_CONTEXT (decl);
3088 else if (CP_DECL_CONTEXT (decl)
3089 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3090 /* In the case of a virtual function, we want the class in which
3092 ctx = CP_DECL_CONTEXT (decl);
3094 /* Otherwise, if we're currently defining some class, the DECL
3095 is assumed to be a member of the class. */
3096 ctx = current_scope ();
3098 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3101 if (!DECL_CONTEXT (decl))
3102 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3104 /* See if this is a primary template. */
3105 if (is_friend && ctx)
3106 /* A friend template that specifies a class context, i.e.
3107 template <typename T> friend void A<T>::f();
3111 primary = template_parm_scope_p ();
3115 if (DECL_CLASS_SCOPE_P (decl))
3116 member_template_p = true;
3117 if (TREE_CODE (decl) == TYPE_DECL
3118 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3119 error ("template class without a name");
3120 else if (TREE_CODE (decl) == FUNCTION_DECL)
3122 if (DECL_DESTRUCTOR_P (decl))
3126 A destructor shall not be a member template. */
3127 error ("destructor %qD declared as member template", decl);
3128 return error_mark_node;
3130 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3131 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3132 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3133 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3134 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3135 == void_list_node)))
3137 /* [basic.stc.dynamic.allocation]
3139 An allocation function can be a function
3140 template. ... Template allocation functions shall
3141 have two or more parameters. */
3142 error ("invalid template declaration of %qD", decl);
3143 return error_mark_node;
3146 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3147 && CLASS_TYPE_P (TREE_TYPE (decl)))
3151 error ("template declaration of %q#D", decl);
3152 return error_mark_node;
3156 /* Check to see that the rules regarding the use of default
3157 arguments are not being violated. */
3158 check_default_tmpl_args (decl, current_template_parms,
3159 primary, is_partial);
3162 return process_partial_specialization (decl);
3164 args = current_template_args ();
3167 || TREE_CODE (ctx) == FUNCTION_DECL
3168 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3169 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3171 if (DECL_LANG_SPECIFIC (decl)
3172 && DECL_TEMPLATE_INFO (decl)
3173 && DECL_TI_TEMPLATE (decl))
3174 tmpl = DECL_TI_TEMPLATE (decl);
3175 /* If DECL is a TYPE_DECL for a class-template, then there won't
3176 be DECL_LANG_SPECIFIC. The information equivalent to
3177 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3178 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3179 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3180 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3182 /* Since a template declaration already existed for this
3183 class-type, we must be redeclaring it here. Make sure
3184 that the redeclaration is valid. */
3185 redeclare_class_template (TREE_TYPE (decl),
3186 current_template_parms);
3187 /* We don't need to create a new TEMPLATE_DECL; just use the
3188 one we already had. */
3189 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3193 tmpl = build_template_decl (decl, current_template_parms,
3197 if (DECL_LANG_SPECIFIC (decl)
3198 && DECL_TEMPLATE_SPECIALIZATION (decl))
3200 /* A specialization of a member template of a template
3202 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3203 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3204 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3210 tree a, t, current, parms;
3213 if (TREE_CODE (decl) == TYPE_DECL)
3215 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
3216 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
3217 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3218 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3219 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3222 error ("%qD does not declare a template type", decl);
3226 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
3228 error ("template definition of non-template %q#D", decl);
3232 tmpl = DECL_TI_TEMPLATE (decl);
3234 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3235 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3236 && DECL_TEMPLATE_SPECIALIZATION (decl)
3237 && DECL_MEMBER_TEMPLATE_P (tmpl))
3241 /* The declaration is a specialization of a member
3242 template, declared outside the class. Therefore, the
3243 innermost template arguments will be NULL, so we
3244 replace them with the arguments determined by the
3245 earlier call to check_explicit_specialization. */
3246 args = DECL_TI_ARGS (decl);
3249 = build_template_decl (decl, current_template_parms,
3251 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3252 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3253 DECL_TI_TEMPLATE (decl) = new_tmpl;
3254 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3255 DECL_TEMPLATE_INFO (new_tmpl)
3256 = tree_cons (tmpl, args, NULL_TREE);
3258 register_specialization (new_tmpl,
3259 most_general_template (tmpl),
3265 /* Make sure the template headers we got make sense. */
3267 parms = DECL_TEMPLATE_PARMS (tmpl);
3268 i = TMPL_PARMS_DEPTH (parms);
3269 if (TMPL_ARGS_DEPTH (args) != i)
3271 error ("expected %d levels of template parms for %q#D, got %d",
3272 i, decl, TMPL_ARGS_DEPTH (args));
3275 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3277 a = TMPL_ARGS_LEVEL (args, i);
3278 t = INNERMOST_TEMPLATE_PARMS (parms);
3280 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3282 if (current == decl)
3283 error ("got %d template parameters for %q#D",
3284 TREE_VEC_LENGTH (a), decl);
3286 error ("got %d template parameters for %q#T",
3287 TREE_VEC_LENGTH (a), current);
3288 error (" but %d required", TREE_VEC_LENGTH (t));
3289 return error_mark_node;
3292 /* Perhaps we should also check that the parms are used in the
3293 appropriate qualifying scopes in the declarator? */
3295 if (current == decl)
3298 current = TYPE_CONTEXT (current);
3302 DECL_TEMPLATE_RESULT (tmpl) = decl;
3303 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3305 /* Push template declarations for global functions and types. Note
3306 that we do not try to push a global template friend declared in a
3307 template class; such a thing may well depend on the template
3308 parameters of the class. */
3309 if (new_template_p && !ctx
3310 && !(is_friend && template_class_depth (current_class_type) > 0))
3312 tmpl = pushdecl_namespace_level (tmpl, is_friend);
3313 if (tmpl == error_mark_node)
3314 return error_mark_node;
3316 /* Hide template friend classes that haven't been declared yet. */
3317 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
3319 DECL_ANTICIPATED (tmpl) = 1;
3320 DECL_FRIEND_P (tmpl) = 1;
3326 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3327 if (DECL_CONV_FN_P (tmpl))
3329 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3331 /* It is a conversion operator. See if the type converted to
3332 depends on innermost template operands. */
3334 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3336 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3340 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3341 back to its most general template. If TMPL is a specialization,
3342 ARGS may only have the innermost set of arguments. Add the missing
3343 argument levels if necessary. */
3344 if (DECL_TEMPLATE_INFO (tmpl))
3345 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3347 info = tree_cons (tmpl, args, NULL_TREE);
3349 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3350 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3351 else if (DECL_LANG_SPECIFIC (decl))
3352 DECL_TEMPLATE_INFO (decl) = info;
3354 return DECL_TEMPLATE_RESULT (tmpl);
3358 push_template_decl (tree decl)
3360 return push_template_decl_real (decl, false);
3363 /* Called when a class template TYPE is redeclared with the indicated
3364 template PARMS, e.g.:
3366 template <class T> struct S;
3367 template <class T> struct S {}; */
3370 redeclare_class_template (tree type, tree parms)
3376 if (!TYPE_TEMPLATE_INFO (type))
3378 error ("%qT is not a template type", type);
3382 tmpl = TYPE_TI_TEMPLATE (type);
3383 if (!PRIMARY_TEMPLATE_P (tmpl))
3384 /* The type is nested in some template class. Nothing to worry
3385 about here; there are no new template parameters for the nested
3391 error ("template specifiers not specified in declaration of %qD",
3396 parms = INNERMOST_TEMPLATE_PARMS (parms);
3397 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3399 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3401 error ("previous declaration %q+D", tmpl);
3402 error ("used %d template parameter(s) instead of %d",
3403 TREE_VEC_LENGTH (tmpl_parms),
3404 TREE_VEC_LENGTH (parms));
3408 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3415 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
3416 || TREE_VEC_ELT (parms, i) == error_mark_node)
3419 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3420 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3421 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3422 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3424 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
3426 if (tmpl_parm != error_mark_node
3427 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
3428 || (TREE_CODE (tmpl_parm) != TYPE_DECL
3429 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
3431 error ("template parameter %q+#D", tmpl_parm);
3432 error ("redeclared here as %q#D", parm);
3436 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3438 /* We have in [temp.param]:
3440 A template-parameter may not be given default arguments
3441 by two different declarations in the same scope. */
3442 error ("redefinition of default argument for %q#D", parm);
3443 error ("%J original definition appeared here", tmpl_parm);
3447 if (parm_default != NULL_TREE)
3448 /* Update the previous template parameters (which are the ones
3449 that will really count) with the new default value. */
3450 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3451 else if (tmpl_default != NULL_TREE)
3452 /* Update the new parameters, too; they'll be used as the
3453 parameters for any members. */
3454 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3460 /* Simplify EXPR if it is a non-dependent expression. Returns the
3461 (possibly simplified) expression. */
3464 fold_non_dependent_expr (tree expr)
3466 if (expr == NULL_TREE)
3469 /* If we're in a template, but EXPR isn't value dependent, simplify
3470 it. We're supposed to treat:
3472 template <typename T> void f(T[1 + 1]);
3473 template <typename T> void f(T[2]);
3475 as two declarations of the same function, for example. */
3476 if (processing_template_decl
3477 && !type_dependent_expression_p (expr)
3478 && !value_dependent_expression_p (expr))
3480 HOST_WIDE_INT saved_processing_template_decl;
3482 saved_processing_template_decl = processing_template_decl;
3483 processing_template_decl = 0;
3484 expr = tsubst_copy_and_build (expr,
3487 /*in_decl=*/NULL_TREE,
3488 /*function_p=*/false,
3489 /*integral_constant_expression_p=*/true);
3490 processing_template_decl = saved_processing_template_decl;
3495 /* EXPR is an expression which is used in a constant-expression context.
3496 For instance, it could be a VAR_DECL with a constant initializer.
3497 Extract the innest constant expression.
3499 This is basically a more powerful version of
3500 integral_constant_value, which can be used also in templates where
3501 initializers can maintain a syntactic rather than semantic form
3502 (even if they are non-dependent, for access-checking purposes). */
3505 fold_decl_constant_value (tree expr)
3507 tree const_expr = expr;
3510 expr = fold_non_dependent_expr (const_expr);
3511 const_expr = integral_constant_value (expr);
3513 while (expr != const_expr);
3518 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
3519 must be a function or a pointer-to-function type, as specified
3520 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
3521 and check that the resulting function has external linkage. */
3524 convert_nontype_argument_function (tree type, tree expr)
3529 fn = instantiate_type (type, fns, tf_none);
3530 if (fn == error_mark_node)
3531 return error_mark_node;
3534 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
3535 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
3536 if (TREE_CODE (fn_no_ptr) == BASELINK)
3537 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
3539 /* [temp.arg.nontype]/1
3541 A template-argument for a non-type, non-template template-parameter
3544 -- the address of an object or function with external linkage. */
3545 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
3547 error ("%qE is not a valid template argument for type %qT "
3548 "because function %qD has not external linkage",
3549 expr, type, fn_no_ptr);
3556 /* Attempt to convert the non-type template parameter EXPR to the
3557 indicated TYPE. If the conversion is successful, return the
3558 converted value. If the conversion is unsuccessful, return
3559 NULL_TREE if we issued an error message, or error_mark_node if we
3560 did not. We issue error messages for out-and-out bad template
3561 parameters, but not simply because the conversion failed, since we
3562 might be just trying to do argument deduction. Both TYPE and EXPR
3563 must be non-dependent.
3565 The conversion follows the special rules described in
3566 [temp.arg.nontype], and it is much more strict than an implicit
3569 This function is called twice for each template argument (see
3570 lookup_template_class for a more accurate description of this
3571 problem). This means that we need to handle expressions which
3572 are not valid in a C++ source, but can be created from the
3573 first call (for instance, casts to perform conversions). These
3574 hacks can go away after we fix the double coercion problem. */
3577 convert_nontype_argument (tree type, tree expr)
3581 /* Detect immediately string literals as invalid non-type argument.
3582 This special-case is not needed for correctness (we would easily
3583 catch this later), but only to provide better diagnostic for this
3584 common user mistake. As suggested by DR 100, we do not mention
3585 linkage issues in the diagnostic as this is not the point. */
3586 if (TREE_CODE (expr) == STRING_CST)
3588 error ("%qE is not a valid template argument for type %qT "
3589 "because string literals can never be used in this context",
3594 /* If we are in a template, EXPR may be non-dependent, but still
3595 have a syntactic, rather than semantic, form. For example, EXPR
3596 might be a SCOPE_REF, rather than the VAR_DECL to which the
3597 SCOPE_REF refers. Preserving the qualifying scope is necessary
3598 so that access checking can be performed when the template is
3599 instantiated -- but here we need the resolved form so that we can
3600 convert the argument. */
3601 expr = fold_non_dependent_expr (expr);
3602 if (error_operand_p (expr))
3603 return error_mark_node;
3604 expr_type = TREE_TYPE (expr);
3606 /* HACK: Due to double coercion, we can get a
3607 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
3608 which is the tree that we built on the first call (see
3609 below when coercing to reference to object or to reference to
3610 function). We just strip everything and get to the arg.
3611 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
3613 if (TREE_CODE (expr) == NOP_EXPR)
3615 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
3617 /* ??? Maybe we could use convert_from_reference here, but we
3618 would need to relax its constraints because the NOP_EXPR
3619 could actually change the type to something more cv-qualified,
3620 and this is not folded by convert_from_reference. */
3621 tree addr = TREE_OPERAND (expr, 0);
3622 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
3623 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
3624 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
3625 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3626 (TREE_TYPE (expr_type),
3627 TREE_TYPE (TREE_TYPE (addr))));
3629 expr = TREE_OPERAND (addr, 0);
3630 expr_type = TREE_TYPE (expr);
3633 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
3634 parameter is a pointer to object, through decay and
3635 qualification conversion. Let's strip everything. */
3636 else if (TYPE_PTROBV_P (type))
3639 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
3640 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
3641 /* Skip the ADDR_EXPR only if it is part of the decay for
3642 an array. Otherwise, it is part of the original argument
3643 in the source code. */
3644 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
3645 expr = TREE_OPERAND (expr, 0);
3646 expr_type = TREE_TYPE (expr);
3650 /* [temp.arg.nontype]/5, bullet 1
3652 For a non-type template-parameter of integral or enumeration type,
3653 integral promotions (_conv.prom_) and integral conversions
3654 (_conv.integral_) are applied. */
3655 if (INTEGRAL_TYPE_P (type))
3657 if (!INTEGRAL_TYPE_P (expr_type))
3658 return error_mark_node;
3660 expr = fold_decl_constant_value (expr);
3661 /* Notice that there are constant expressions like '4 % 0' which
3662 do not fold into integer constants. */
3663 if (TREE_CODE (expr) != INTEGER_CST)
3665 error ("%qE is not a valid template argument for type %qT "
3666 "because it is a non-constant expression", expr, type);
3670 /* At this point, an implicit conversion does what we want,
3671 because we already know that the expression is of integral
3673 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
3674 if (expr == error_mark_node)
3675 return error_mark_node;
3677 /* Conversion was allowed: fold it to a bare integer constant. */
3680 /* [temp.arg.nontype]/5, bullet 2
3682 For a non-type template-parameter of type pointer to object,
3683 qualification conversions (_conv.qual_) and the array-to-pointer
3684 conversion (_conv.array_) are applied. */
3685 else if (TYPE_PTROBV_P (type))
3687 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
3689 A template-argument for a non-type, non-template template-parameter
3690 shall be one of: [...]
3692 -- the name of a non-type template-parameter;
3693 -- the address of an object or function with external linkage, [...]
3694 expressed as "& id-expression" where the & is optional if the name
3695 refers to a function or array, or if the corresponding
3696 template-parameter is a reference.
3698 Here, we do not care about functions, as they are invalid anyway
3699 for a parameter of type pointer-to-object. */
3701 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
3702 /* Non-type template parameters are OK. */
3704 else if (TREE_CODE (expr) != ADDR_EXPR
3705 && TREE_CODE (expr_type) != ARRAY_TYPE)
3707 if (TREE_CODE (expr) == VAR_DECL)
3709 error ("%qD is not a valid template argument "
3710 "because %qD is a variable, not the address of "
3715 /* Other values, like integer constants, might be valid
3716 non-type arguments of some other type. */
3717 return error_mark_node;
3723 decl = ((TREE_CODE (expr) == ADDR_EXPR)
3724 ? TREE_OPERAND (expr, 0) : expr);
3725 if (TREE_CODE (decl) != VAR_DECL)
3727 error ("%qE is not a valid template argument of type %qT "
3728 "because %qE is not a variable",
3732 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
3734 error ("%qE is not a valid template argument of type %qT "
3735 "because %qD does not have external linkage",
3741 expr = decay_conversion (expr);
3742 if (expr == error_mark_node)
3743 return error_mark_node;
3745 expr = perform_qualification_conversions (type, expr);
3746 if (expr == error_mark_node)
3747 return error_mark_node;
3749 /* [temp.arg.nontype]/5, bullet 3
3751 For a non-type template-parameter of type reference to object, no
3752 conversions apply. The type referred to by the reference may be more
3753 cv-qualified than the (otherwise identical) type of the
3754 template-argument. The template-parameter is bound directly to the
3755 template-argument, which must be an lvalue. */
3756 else if (TYPE_REF_OBJ_P (type))
3758 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
3760 return error_mark_node;
3762 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
3764 error ("%qE is not a valid template argument for type %qT "
3765 "because of conflicts in cv-qualification", expr, type);
3769 if (!real_lvalue_p (expr))
3771 error ("%qE is not a valid template argument for type %qT "
3772 "because it is not an lvalue", expr, type);
3776 /* [temp.arg.nontype]/1
3778 A template-argument for a non-type, non-template template-parameter
3779 shall be one of: [...]
3781 -- the address of an object or function with external linkage. */
3782 if (!DECL_EXTERNAL_LINKAGE_P (expr))
3784 error ("%qE is not a valid template argument for type %qT "
3785 "because object %qD has not external linkage",
3790 expr = build_nop (type, build_address (expr));
3792 /* [temp.arg.nontype]/5, bullet 4
3794 For a non-type template-parameter of type pointer to function, only
3795 the function-to-pointer conversion (_conv.func_) is applied. If the
3796 template-argument represents a set of overloaded functions (or a
3797 pointer to such), the matching function is selected from the set
3799 else if (TYPE_PTRFN_P (type))
3801 /* If the argument is a template-id, we might not have enough
3802 context information to decay the pointer. */
3803 if (!type_unknown_p (expr_type))
3805 expr = decay_conversion (expr);
3806 if (expr == error_mark_node)
3807 return error_mark_node;
3810 expr = convert_nontype_argument_function (type, expr);
3811 if (!expr || expr == error_mark_node)
3814 /* [temp.arg.nontype]/5, bullet 5
3816 For a non-type template-parameter of type reference to function, no
3817 conversions apply. If the template-argument represents a set of
3818 overloaded functions, the matching function is selected from the set
3820 else if (TYPE_REFFN_P (type))
3822 if (TREE_CODE (expr) == ADDR_EXPR)
3824 error ("%qE is not a valid template argument for type %qT "
3825 "because it is a pointer", expr, type);
3826 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
3830 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
3831 if (!expr || expr == error_mark_node)
3834 expr = build_nop (type, build_address (expr));
3836 /* [temp.arg.nontype]/5, bullet 6
3838 For a non-type template-parameter of type pointer to member function,
3839 no conversions apply. If the template-argument represents a set of
3840 overloaded member functions, the matching member function is selected
3841 from the set (_over.over_). */
3842 else if (TYPE_PTRMEMFUNC_P (type))
3844 expr = instantiate_type (type, expr, tf_none);
3845 if (expr == error_mark_node)
3846 return error_mark_node;
3848 /* There is no way to disable standard conversions in
3849 resolve_address_of_overloaded_function (called by
3850 instantiate_type). It is possible that the call succeeded by
3851 converting &B::I to &D::I (where B is a base of D), so we need
3852 to reject this conversion here.
3854 Actually, even if there was a way to disable standard conversions,
3855 it would still be better to reject them here so that we can
3856 provide a superior diagnostic. */
3857 if (!same_type_p (TREE_TYPE (expr), type))
3859 /* Make sure we are just one standard conversion off. */
3860 gcc_assert (can_convert (type, TREE_TYPE (expr)));
3861 error ("%qE is not a valid template argument for type %qT "
3862 "because it is of type %qT", expr, type,
3864 inform ("standard conversions are not allowed in this context");
3868 /* [temp.arg.nontype]/5, bullet 7
3870 For a non-type template-parameter of type pointer to data member,
3871 qualification conversions (_conv.qual_) are applied. */
3872 else if (TYPE_PTRMEM_P (type))
3874 expr = perform_qualification_conversions (type, expr);
3875 if (expr == error_mark_node)
3878 /* A template non-type parameter must be one of the above. */
3882 /* Sanity check: did we actually convert the argument to the
3884 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
3889 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3890 template template parameters. Both PARM_PARMS and ARG_PARMS are
3891 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3894 Consider the example:
3895 template <class T> class A;
3896 template<template <class U> class TT> class B;
3898 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
3899 the parameters to A, and OUTER_ARGS contains A. */
3902 coerce_template_template_parms (tree parm_parms,
3904 tsubst_flags_t complain,
3908 int nparms, nargs, i;
3911 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
3912 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
3914 nparms = TREE_VEC_LENGTH (parm_parms);
3915 nargs = TREE_VEC_LENGTH (arg_parms);
3917 if (nargs != nparms)
3920 for (i = 0; i < nparms; ++i)
3922 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
3923 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
3926 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3927 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3929 if (arg == NULL_TREE || arg == error_mark_node
3930 || parm == NULL_TREE || parm == error_mark_node)
3933 if (TREE_CODE (arg) != TREE_CODE (parm))
3936 switch (TREE_CODE (parm))
3942 /* We encounter instantiations of templates like
3943 template <template <template <class> class> class TT>
3946 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3947 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3949 if (!coerce_template_template_parms
3950 (parmparm, argparm, complain, in_decl, outer_args))
3956 /* The tsubst call is used to handle cases such as
3958 template <int> class C {};
3959 template <class T, template <T> class TT> class D {};
3962 i.e. the parameter list of TT depends on earlier parameters. */
3963 if (!dependent_type_p (TREE_TYPE (arg))
3965 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3977 /* Convert the indicated template ARG as necessary to match the
3978 indicated template PARM. Returns the converted ARG, or
3979 error_mark_node if the conversion was unsuccessful. Error and
3980 warning messages are issued under control of COMPLAIN. This
3981 conversion is for the Ith parameter in the parameter list. ARGS is
3982 the full set of template arguments deduced so far. */
3985 convert_template_argument (tree parm,
3988 tsubst_flags_t complain,
3993 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3995 if (TREE_CODE (arg) == TREE_LIST
3996 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3998 /* The template argument was the name of some
3999 member function. That's usually
4000 invalid, but static members are OK. In any
4001 case, grab the underlying fields/functions
4002 and issue an error later if required. */
4003 arg = TREE_VALUE (arg);
4004 TREE_TYPE (arg) = unknown_type_node;
4007 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
4008 requires_type = (TREE_CODE (parm) == TYPE_DECL
4009 || requires_tmpl_type);
4011 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
4012 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
4013 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4014 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
4017 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4018 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
4019 arg = TYPE_STUB_DECL (arg);
4021 is_type = TYPE_P (arg) || is_tmpl_type;
4023 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
4024 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
4026 pedwarn ("to refer to a type member of a template parameter, "
4027 "use %<typename %E%>", arg);
4029 arg = make_typename_type (TREE_OPERAND (arg, 0),
4030 TREE_OPERAND (arg, 1),
4032 complain & tf_error);
4035 if (is_type != requires_type)
4039 if (complain & tf_error)
4041 error ("type/value mismatch at argument %d in template "
4042 "parameter list for %qD",
4045 error (" expected a constant of type %qT, got %qT",
4047 (is_tmpl_type ? DECL_NAME (arg) : arg));
4048 else if (requires_tmpl_type)
4049 error (" expected a class template, got %qE", arg);
4051 error (" expected a type, got %qE", arg);
4054 return error_mark_node;
4056 if (is_tmpl_type ^ requires_tmpl_type)
4058 if (in_decl && (complain & tf_error))
4060 error ("type/value mismatch at argument %d in template "
4061 "parameter list for %qD",
4064 error (" expected a type, got %qT", DECL_NAME (arg));
4066 error (" expected a class template, got %qT", arg);
4068 return error_mark_node;
4073 if (requires_tmpl_type)
4075 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4076 /* The number of argument required is not known yet.
4077 Just accept it for now. */
4078 val = TREE_TYPE (arg);
4081 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4082 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4084 if (coerce_template_template_parms (parmparm, argparm,
4090 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4092 if (val != error_mark_node
4093 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4094 val = TREE_TYPE (val);
4098 if (in_decl && (complain & tf_error))
4100 error ("type/value mismatch at argument %d in "
4101 "template parameter list for %qD",
4103 error (" expected a template of type %qD, got %qD",
4107 val = error_mark_node;
4113 /* We only form one instance of each template specialization.
4114 Therefore, if we use a non-canonical variant (i.e., a
4115 typedef), any future messages referring to the type will use
4116 the typedef, which is confusing if those future uses do not
4117 themselves also use the typedef. */
4119 val = canonical_type_variant (val);
4123 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4125 if (invalid_nontype_parm_type_p (t, complain))
4126 return error_mark_node;
4128 if (!uses_template_parms (arg) && !uses_template_parms (t))
4129 /* We used to call digest_init here. However, digest_init
4130 will report errors, which we don't want when complain
4131 is zero. More importantly, digest_init will try too
4132 hard to convert things: for example, `0' should not be
4133 converted to pointer type at this point according to
4134 the standard. Accepting this is not merely an
4135 extension, since deciding whether or not these
4136 conversions can occur is part of determining which
4137 function template to call, or whether a given explicit
4138 argument specification is valid. */
4139 val = convert_nontype_argument (t, arg);
4143 if (val == NULL_TREE)
4144 val = error_mark_node;
4145 else if (val == error_mark_node && (complain & tf_error))
4146 error ("could not convert template argument %qE to %qT", arg, t);
4152 /* Convert all template arguments to their appropriate types, and
4153 return a vector containing the innermost resulting template
4154 arguments. If any error occurs, return error_mark_node. Error and
4155 warning messages are issued under control of COMPLAIN.
4157 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
4158 for arguments not specified in ARGS. Otherwise, if
4159 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
4160 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
4161 USE_DEFAULT_ARGS is false, then all arguments must be specified in
4165 coerce_template_parms (tree parms,
4168 tsubst_flags_t complain,
4169 bool require_all_args,
4170 bool use_default_args)
4172 int nparms, nargs, i, lost = 0;
4175 tree new_inner_args;
4176 bool saved_skip_evaluation;
4178 inner_args = INNERMOST_TEMPLATE_ARGS (args);
4179 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4180 nparms = TREE_VEC_LENGTH (parms);
4185 && (!use_default_args
4186 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
4187 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
4189 if (complain & tf_error)
4191 error ("wrong number of template arguments (%d, should be %d)",
4195 error ("provided for %q+D", in_decl);
4198 return error_mark_node;
4201 /* We need to evaluate the template arguments, even though this
4202 template-id may be nested within a "sizeof". */
4203 saved_skip_evaluation = skip_evaluation;
4204 skip_evaluation = false;
4205 new_inner_args = make_tree_vec (nparms);
4206 new_args = add_outermost_template_args (args, new_inner_args);
4207 for (i = 0; i < nparms; i++)
4212 /* Get the Ith template parameter. */
4213 parm = TREE_VEC_ELT (parms, i);
4215 if (parm == error_mark_node)
4217 TREE_VEC_ELT (new_inner_args, i) = error_mark_node;
4221 /* Calculate the Ith argument. */
4223 arg = TREE_VEC_ELT (inner_args, i);
4224 else if (require_all_args)
4225 /* There must be a default arg in this case. */
4226 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
4232 if (arg == error_mark_node)
4234 if (complain & tf_error)
4235 error ("template argument %d is invalid", i + 1);
4238 arg = convert_template_argument (TREE_VALUE (parm),
4239 arg, new_args, complain, i,
4242 if (arg == error_mark_node)
4244 TREE_VEC_ELT (new_inner_args, i) = arg;
4246 skip_evaluation = saved_skip_evaluation;
4249 return error_mark_node;
4251 return new_inner_args;
4254 /* Returns 1 if template args OT and NT are equivalent. */
4257 template_args_equal (tree ot, tree nt)
4262 if (TREE_CODE (nt) == TREE_VEC)
4263 /* For member templates */
4264 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
4265 else if (TYPE_P (nt))
4266 return TYPE_P (ot) && same_type_p (ot, nt);
4267 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
4270 return cp_tree_equal (ot, nt);
4273 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
4274 of template arguments. Returns 0 otherwise. */
4277 comp_template_args (tree oldargs, tree newargs)
4281 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
4284 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
4286 tree nt = TREE_VEC_ELT (newargs, i);
4287 tree ot = TREE_VEC_ELT (oldargs, i);
4289 if (! template_args_equal (ot, nt))
4296 add_pending_template (tree d)
4298 tree ti = (TYPE_P (d)
4299 ? CLASSTYPE_TEMPLATE_INFO (d)
4300 : DECL_TEMPLATE_INFO (d));
4304 if (TI_PENDING_TEMPLATE_FLAG (ti))
4307 /* We are called both from instantiate_decl, where we've already had a
4308 tinst_level pushed, and instantiate_template, where we haven't.
4310 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4313 push_tinst_level (d);
4315 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4316 if (last_pending_template)
4317 TREE_CHAIN (last_pending_template) = pt;
4319 pending_templates = pt;
4321 last_pending_template = pt;
4323 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4330 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4331 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4332 documentation for TEMPLATE_ID_EXPR. */
4335 lookup_template_function (tree fns, tree arglist)
4339 if (fns == error_mark_node || arglist == error_mark_node)
4340 return error_mark_node;
4342 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
4343 gcc_assert (fns && (is_overloaded_fn (fns)
4344 || TREE_CODE (fns) == IDENTIFIER_NODE));
4346 if (BASELINK_P (fns))
4348 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
4350 BASELINK_FUNCTIONS (fns),
4355 type = TREE_TYPE (fns);
4356 if (TREE_CODE (fns) == OVERLOAD || !type)
4357 type = unknown_type_node;
4359 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
4362 /* Within the scope of a template class S<T>, the name S gets bound
4363 (in build_self_reference) to a TYPE_DECL for the class, not a
4364 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4365 or one of its enclosing classes, and that type is a template,
4366 return the associated TEMPLATE_DECL. Otherwise, the original
4367 DECL is returned. */
4370 maybe_get_template_decl_from_type_decl (tree decl)
4372 return (decl != NULL_TREE
4373 && TREE_CODE (decl) == TYPE_DECL
4374 && DECL_ARTIFICIAL (decl)
4375 && CLASS_TYPE_P (TREE_TYPE (decl))
4376 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4377 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4380 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4381 parameters, find the desired type.
4383 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4385 IN_DECL, if non-NULL, is the template declaration we are trying to
4388 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4389 the class we are looking up.
4391 Issue error and warning messages under control of COMPLAIN.
4393 If the template class is really a local class in a template
4394 function, then the FUNCTION_CONTEXT is the function in which it is
4397 ??? Note that this function is currently called *twice* for each
4398 template-id: the first time from the parser, while creating the
4399 incomplete type (finish_template_type), and the second type during the
4400 real instantiation (instantiate_template_class). This is surely something
4401 that we want to avoid. It also causes some problems with argument
4402 coercion (see convert_nontype_argument for more information on this). */
4405 lookup_template_class (tree d1,
4410 tsubst_flags_t complain)
4412 tree template = NULL_TREE, parmlist;
4415 timevar_push (TV_NAME_LOOKUP);
4417 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4419 tree value = innermost_non_namespace_value (d1);
4420 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
4425 push_decl_namespace (context);
4426 template = lookup_name (d1);
4427 template = maybe_get_template_decl_from_type_decl (template);
4429 pop_decl_namespace ();
4432 context = DECL_CONTEXT (template);
4434 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4436 tree type = TREE_TYPE (d1);
4438 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4439 an implicit typename for the second A. Deal with it. */
4440 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4441 type = TREE_TYPE (type);
4443 if (CLASSTYPE_TEMPLATE_INFO (type))
4445 template = CLASSTYPE_TI_TEMPLATE (type);
4446 d1 = DECL_NAME (template);
4449 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4450 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4452 template = TYPE_TI_TEMPLATE (d1);
4453 d1 = DECL_NAME (template);
4455 else if (TREE_CODE (d1) == TEMPLATE_DECL
4456 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4459 d1 = DECL_NAME (template);
4460 context = DECL_CONTEXT (template);
4463 /* Issue an error message if we didn't find a template. */
4466 if (complain & tf_error)
4467 error ("%qT is not a template", d1);
4468 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4471 if (TREE_CODE (template) != TEMPLATE_DECL
4472 /* Make sure it's a user visible template, if it was named by
4474 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4475 && !PRIMARY_TEMPLATE_P (template)))
4477 if (complain & tf_error)
4479 error ("non-template type %qT used as a template", d1);
4481 error ("for template declaration %q+D", in_decl);
4483 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4486 complain &= ~tf_user;
4488 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4490 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4491 template arguments */
4496 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4498 /* Consider an example where a template template parameter declared as
4500 template <class T, class U = std::allocator<T> > class TT
4502 The template parameter level of T and U are one level larger than
4503 of TT. To proper process the default argument of U, say when an
4504 instantiation `TT<int>' is seen, we need to build the full
4505 arguments containing {int} as the innermost level. Outer levels,
4506 available when not appearing as default template argument, can be
4507 obtained from `current_template_args ()'.
4509 Suppose that TT is later substituted with std::vector. The above
4510 instantiation is `TT<int, std::allocator<T> >' with TT at
4511 level 1, and T at level 2, while the template arguments at level 1
4512 becomes {std::vector} and the inner level 2 is {int}. */
4514 if (current_template_parms)
4515 arglist = add_to_template_args (current_template_args (), arglist);
4517 arglist2 = coerce_template_parms (parmlist, arglist, template,
4519 /*require_all_args=*/true,
4520 /*use_default_args=*/true);
4521 if (arglist2 == error_mark_node
4522 || (!uses_template_parms (arglist2)
4523 && check_instantiated_args (template, arglist2, complain)))
4524 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4526 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4527 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4531 tree template_type = TREE_TYPE (template);
4534 tree found = NULL_TREE;
4537 int is_partial_instantiation;
4539 gen_tmpl = most_general_template (template);
4540 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4541 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4542 arg_depth = TMPL_ARGS_DEPTH (arglist);
4544 if (arg_depth == 1 && parm_depth > 1)
4546 /* We've been given an incomplete set of template arguments.
4549 template <class T> struct S1 {
4550 template <class U> struct S2 {};
4551 template <class U> struct S2<U*> {};
4554 we will be called with an ARGLIST of `U*', but the
4555 TEMPLATE will be `template <class T> template
4556 <class U> struct S1<T>::S2'. We must fill in the missing
4559 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4561 arg_depth = TMPL_ARGS_DEPTH (arglist);
4564 /* Now we should have enough arguments. */
4565 gcc_assert (parm_depth == arg_depth);
4567 /* From here on, we're only interested in the most general
4569 template = gen_tmpl;
4571 /* Calculate the BOUND_ARGS. These will be the args that are
4572 actually tsubst'd into the definition to create the
4576 /* We have multiple levels of arguments to coerce, at once. */
4578 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4580 tree bound_args = make_tree_vec (parm_depth);
4582 for (i = saved_depth,
4583 t = DECL_TEMPLATE_PARMS (template);
4584 i > 0 && t != NULL_TREE;
4585 --i, t = TREE_CHAIN (t))
4587 tree a = coerce_template_parms (TREE_VALUE (t),
4590 /*require_all_args=*/true,
4591 /*use_default_args=*/true);
4593 /* Don't process further if one of the levels fails. */
4594 if (a == error_mark_node)
4596 /* Restore the ARGLIST to its full size. */
4597 TREE_VEC_LENGTH (arglist) = saved_depth;
4598 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4601 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4603 /* We temporarily reduce the length of the ARGLIST so
4604 that coerce_template_parms will see only the arguments
4605 corresponding to the template parameters it is
4607 TREE_VEC_LENGTH (arglist)--;
4610 /* Restore the ARGLIST to its full size. */
4611 TREE_VEC_LENGTH (arglist) = saved_depth;
4613 arglist = bound_args;
4617 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4618 INNERMOST_TEMPLATE_ARGS (arglist),
4621 /*require_all_args=*/true,
4622 /*use_default_args=*/true);
4624 if (arglist == error_mark_node)
4625 /* We were unable to bind the arguments. */
4626 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4628 /* In the scope of a template class, explicit references to the
4629 template class refer to the type of the template, not any
4630 instantiation of it. For example, in:
4632 template <class T> class C { void f(C<T>); }
4634 the `C<T>' is just the same as `C'. Outside of the
4635 class, however, such a reference is an instantiation. */
4636 if (comp_template_args (TYPE_TI_ARGS (template_type),
4639 found = template_type;
4641 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4645 for (ctx = current_class_type;
4646 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4648 ? TYPE_CONTEXT (ctx)
4649 : DECL_CONTEXT (ctx)))
4650 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4653 /* We're not in the scope of the class, so the
4654 TEMPLATE_TYPE is not the type we want after all. */
4660 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4662 /* If we already have this specialization, return it. */
4663 found = retrieve_specialization (template, arglist,
4664 /*class_specializations_p=*/false);
4666 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4668 /* This type is a "partial instantiation" if any of the template
4669 arguments still involve template parameters. Note that we set
4670 IS_PARTIAL_INSTANTIATION for partial specializations as
4672 is_partial_instantiation = uses_template_parms (arglist);
4674 /* If the deduced arguments are invalid, then the binding
4676 if (!is_partial_instantiation
4677 && check_instantiated_args (template,
4678 INNERMOST_TEMPLATE_ARGS (arglist),
4680 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4682 if (!is_partial_instantiation
4683 && !PRIMARY_TEMPLATE_P (template)
4684 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4686 found = xref_tag_from_type (TREE_TYPE (template),
4687 DECL_NAME (template),
4688 /*tag_scope=*/ts_global);
4689 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4692 context = tsubst (DECL_CONTEXT (template), arglist,
4695 context = global_namespace;
4697 /* Create the type. */
4698 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4700 if (!is_partial_instantiation)
4702 set_current_access_from_decl (TYPE_NAME (template_type));
4703 t = start_enum (TYPE_IDENTIFIER (template_type));
4706 /* We don't want to call start_enum for this type, since
4707 the values for the enumeration constants may involve
4708 template parameters. And, no one should be interested
4709 in the enumeration constants for such a type. */
4710 t = make_node (ENUMERAL_TYPE);
4714 t = make_aggr_type (TREE_CODE (template_type));
4715 CLASSTYPE_DECLARED_CLASS (t)
4716 = CLASSTYPE_DECLARED_CLASS (template_type);
4717 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4718 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4720 /* A local class. Make sure the decl gets registered properly. */
4721 if (context == current_function_decl)
4722 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
4724 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
4725 /* This instantiation is another name for the primary
4726 template type. Set the TYPE_CANONICAL field
4728 TYPE_CANONICAL (t) = template_type;
4729 else if (any_template_arguments_need_structural_equality_p (arglist))
4730 /* Some of the template arguments require structural
4731 equality testing, so this template class requires
4732 structural equality testing. */
4733 SET_TYPE_STRUCTURAL_EQUALITY (t);
4736 /* If we called start_enum or pushtag above, this information
4737 will already be set up. */
4740 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4742 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4743 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4744 TYPE_STUB_DECL (t) = type_decl;
4745 DECL_SOURCE_LOCATION (type_decl)
4746 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4749 type_decl = TYPE_NAME (t);
4751 TREE_PRIVATE (type_decl)
4752 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4753 TREE_PROTECTED (type_decl)
4754 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4755 DECL_IN_SYSTEM_HEADER (type_decl)
4756 = DECL_IN_SYSTEM_HEADER (template);
4757 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
4759 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
4760 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
4763 /* Set up the template information. We have to figure out which
4764 template is the immediate parent if this is a full
4766 if (parm_depth == 1 || is_partial_instantiation
4767 || !PRIMARY_TEMPLATE_P (template))
4768 /* This case is easy; there are no member templates involved. */
4772 /* This is a full instantiation of a member template. Look
4773 for a partial instantiation of which this is an instance. */
4775 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4776 found; found = TREE_CHAIN (found))
4779 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4781 /* We only want partial instantiations, here, not
4782 specializations or full instantiations. */
4783 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4784 || !uses_template_parms (TREE_VALUE (found)))
4787 /* Temporarily reduce by one the number of levels in the
4788 ARGLIST and in FOUND so as to avoid comparing the
4789 last set of arguments. */
4790 TREE_VEC_LENGTH (arglist)--;
4791 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4793 /* See if the arguments match. If they do, then TMPL is
4794 the partial instantiation we want. */
4795 success = comp_template_args (TREE_PURPOSE (found), arglist);
4797 /* Restore the argument vectors to their full size. */
4798 TREE_VEC_LENGTH (arglist)++;
4799 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4810 /* There was no partial instantiation. This happens
4811 where C<T> is a member template of A<T> and it's used
4814 template <typename T> struct B { A<T>::C<int> m; };
4817 Create the partial instantiation.
4819 TREE_VEC_LENGTH (arglist)--;
4820 found = tsubst (template, arglist, complain, NULL_TREE);
4821 TREE_VEC_LENGTH (arglist)++;
4825 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4826 DECL_TEMPLATE_INSTANTIATIONS (template)
4827 = tree_cons (arglist, t,
4828 DECL_TEMPLATE_INSTANTIATIONS (template));
4830 if (TREE_CODE (t) == ENUMERAL_TYPE
4831 && !is_partial_instantiation)
4832 /* Now that the type has been registered on the instantiations
4833 list, we set up the enumerators. Because the enumeration
4834 constants may involve the enumeration type itself, we make
4835 sure to register the type first, and then create the
4836 constants. That way, doing tsubst_expr for the enumeration
4837 constants won't result in recursive calls here; we'll find
4838 the instantiation and exit above. */
4839 tsubst_enum (template_type, t, arglist);
4841 if (is_partial_instantiation)
4842 /* If the type makes use of template parameters, the
4843 code that generates debugging information will crash. */
4844 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4846 /* Possibly limit visibility based on template args. */
4847 TREE_PUBLIC (type_decl) = 1;
4848 determine_visibility (type_decl);
4850 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4852 timevar_pop (TV_NAME_LOOKUP);
4859 struct pointer_set_t *visited;
4862 /* Called from for_each_template_parm via walk_tree. */
4865 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
4868 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4869 tree_fn_t fn = pfd->fn;
4870 void *data = pfd->data;
4873 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4874 return error_mark_node;
4876 switch (TREE_CODE (t))
4879 if (TYPE_PTRMEMFUNC_P (t))
4885 if (!TYPE_TEMPLATE_INFO (t))
4887 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4888 fn, data, pfd->visited))
4889 return error_mark_node;
4893 if (for_each_template_parm (TYPE_MIN_VALUE (t),
4894 fn, data, pfd->visited)
4895 || for_each_template_parm (TYPE_MAX_VALUE (t),
4896 fn, data, pfd->visited))
4897 return error_mark_node;
4901 /* Since we're not going to walk subtrees, we have to do this
4903 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4905 return error_mark_node;
4909 /* Check the return type. */
4910 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4911 return error_mark_node;
4913 /* Check the parameter types. Since default arguments are not
4914 instantiated until they are needed, the TYPE_ARG_TYPES may
4915 contain expressions that involve template parameters. But,
4916 no-one should be looking at them yet. And, once they're
4917 instantiated, they don't contain template parameters, so
4918 there's no point in looking at them then, either. */
4922 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4923 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
4925 return error_mark_node;
4927 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4928 want walk_tree walking into them itself. */
4934 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
4936 return error_mark_node;
4941 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
4942 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
4944 return error_mark_node;
4949 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
4950 && for_each_template_parm (DECL_INITIAL (t), fn, data,
4952 return error_mark_node;
4953 if (DECL_CONTEXT (t)
4954 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
4956 return error_mark_node;
4959 case BOUND_TEMPLATE_TEMPLATE_PARM:
4960 /* Record template parameters such as `T' inside `TT<T>'. */
4961 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
4962 return error_mark_node;
4965 case TEMPLATE_TEMPLATE_PARM:
4966 case TEMPLATE_TYPE_PARM:
4967 case TEMPLATE_PARM_INDEX:
4968 if (fn && (*fn)(t, data))
4969 return error_mark_node;
4971 return error_mark_node;
4975 /* A template template parameter is encountered. */
4976 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
4977 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4978 return error_mark_node;
4980 /* Already substituted template template parameter */
4986 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
4987 data, pfd->visited))
4988 return error_mark_node;
4992 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
4993 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4994 (TREE_TYPE (t)), fn, data,
4996 return error_mark_node;
5001 /* If there's no type, then this thing must be some expression
5002 involving template parameters. */
5003 if (!fn && !TREE_TYPE (t))
5004 return error_mark_node;
5009 case REINTERPRET_CAST_EXPR:
5010 case CONST_CAST_EXPR:
5011 case STATIC_CAST_EXPR:
5012 case DYNAMIC_CAST_EXPR:
5016 case PSEUDO_DTOR_EXPR:
5018 return error_mark_node;
5022 /* If we do not handle this case specially, we end up walking
5023 the BINFO hierarchy, which is circular, and therefore
5024 confuses walk_tree. */
5026 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
5028 return error_mark_node;
5035 /* We didn't find any template parameters we liked. */
5039 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
5040 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
5041 call FN with the parameter and the DATA.
5042 If FN returns nonzero, the iteration is terminated, and
5043 for_each_template_parm returns 1. Otherwise, the iteration
5044 continues. If FN never returns a nonzero value, the value
5045 returned by for_each_template_parm is 0. If FN is NULL, it is
5046 considered to be the function which always returns 1. */
5049 for_each_template_parm (tree t, tree_fn_t fn, void* data,
5050 struct pointer_set_t *visited)
5052 struct pair_fn_data pfd;
5059 /* Walk the tree. (Conceptually, we would like to walk without
5060 duplicates, but for_each_template_parm_r recursively calls
5061 for_each_template_parm, so we would need to reorganize a fair
5062 bit to use walk_tree_without_duplicates, so we keep our own
5065 pfd.visited = visited;
5067 pfd.visited = pointer_set_create ();
5068 result = walk_tree (&t,
5069 for_each_template_parm_r,
5071 pfd.visited) != NULL_TREE;
5076 pointer_set_destroy (pfd.visited);
5083 /* Returns true if T depends on any template parameter. */
5086 uses_template_parms (tree t)
5089 int saved_processing_template_decl;
5091 saved_processing_template_decl = processing_template_decl;
5092 if (!saved_processing_template_decl)
5093 processing_template_decl = 1;
5095 dependent_p = dependent_type_p (t);
5096 else if (TREE_CODE (t) == TREE_VEC)
5097 dependent_p = any_dependent_template_arguments_p (t);
5098 else if (TREE_CODE (t) == TREE_LIST)
5099 dependent_p = (uses_template_parms (TREE_VALUE (t))
5100 || uses_template_parms (TREE_CHAIN (t)));
5101 else if (TREE_CODE (t) == TYPE_DECL)
5102 dependent_p = dependent_type_p (TREE_TYPE (t));
5105 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
5106 || TREE_CODE (t) == OVERLOAD
5107 || TREE_CODE (t) == BASELINK
5108 || TREE_CODE (t) == IDENTIFIER_NODE
5109 || CONSTANT_CLASS_P (t))
5110 dependent_p = (type_dependent_expression_p (t)
5111 || value_dependent_expression_p (t));
5114 gcc_assert (t == error_mark_node);
5115 dependent_p = false;
5118 processing_template_decl = saved_processing_template_decl;
5123 /* Returns true if T depends on any template parameter with level LEVEL. */
5126 uses_template_parms_level (tree t, int level)
5128 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
5131 static int tinst_depth;
5132 extern int max_tinst_depth;
5133 #ifdef GATHER_STATISTICS
5136 static int tinst_level_tick;
5137 static int last_template_error_tick;
5139 /* We're starting to instantiate D; record the template instantiation context
5140 for diagnostics and to restore it later. */
5143 push_tinst_level (tree d)
5147 if (tinst_depth >= max_tinst_depth)
5149 /* If the instantiation in question still has unbound template parms,
5150 we don't really care if we can't instantiate it, so just return.
5151 This happens with base instantiation for implicit `typename'. */
5152 if (uses_template_parms (d))
5155 last_template_error_tick = tinst_level_tick;
5156 error ("template instantiation depth exceeds maximum of %d (use "
5157 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
5158 max_tinst_depth, d);
5160 print_instantiation_context ();
5165 new = make_node (TINST_LEVEL);
5166 TINST_DECL (new) = d;
5167 TINST_LOCATION (new) = input_location;
5168 TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
5169 TREE_CHAIN (new) = current_tinst_level;
5170 current_tinst_level = new;
5173 #ifdef GATHER_STATISTICS
5174 if (tinst_depth > depth_reached)
5175 depth_reached = tinst_depth;
5182 /* We're done instantiating this template; return to the instantiation
5186 pop_tinst_level (void)
5188 tree old = current_tinst_level;
5190 /* Restore the filename and line number stashed away when we started
5191 this instantiation. */
5192 input_location = TINST_LOCATION (old);
5193 in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
5194 current_tinst_level = TREE_CHAIN (old);
5199 /* We're instantiating a deferred template; restore the template
5200 instantiation context in which the instantiation was requested, which
5201 is one step out from LEVEL. */
5204 reopen_tinst_level (tree level)
5209 for (t = level; t; t = TREE_CHAIN (t))
5212 current_tinst_level = level;
5216 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
5217 vector of template arguments, as for tsubst.
5219 Returns an appropriate tsubst'd friend declaration. */
5222 tsubst_friend_function (tree decl, tree args)
5226 if (TREE_CODE (decl) == FUNCTION_DECL
5227 && DECL_TEMPLATE_INSTANTIATION (decl)
5228 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
5229 /* This was a friend declared with an explicit template
5230 argument list, e.g.:
5234 to indicate that f was a template instantiation, not a new
5235 function declaration. Now, we have to figure out what
5236 instantiation of what template. */
5238 tree template_id, arglist, fns;
5241 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
5243 /* Friend functions are looked up in the containing namespace scope.
5244 We must enter that scope, to avoid finding member functions of the
5245 current cless with same name. */
5246 push_nested_namespace (ns);
5247 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
5248 tf_warning_or_error, NULL_TREE,
5249 /*integral_constant_expression_p=*/false);
5250 pop_nested_namespace (ns);
5251 arglist = tsubst (DECL_TI_ARGS (decl), args,
5252 tf_warning_or_error, NULL_TREE);
5253 template_id = lookup_template_function (fns, arglist);
5255 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5256 tmpl = determine_specialization (template_id, new_friend,
5258 /*need_member_template=*/0,
5259 TREE_VEC_LENGTH (args),
5261 return instantiate_template (tmpl, new_args, tf_error);
5264 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
5266 /* The NEW_FRIEND will look like an instantiation, to the
5267 compiler, but is not an instantiation from the point of view of
5268 the language. For example, we might have had:
5270 template <class T> struct S {
5271 template <class U> friend void f(T, U);
5274 Then, in S<int>, template <class U> void f(int, U) is not an
5275 instantiation of anything. */
5276 if (new_friend == error_mark_node)
5277 return error_mark_node;
5279 DECL_USE_TEMPLATE (new_friend) = 0;
5280 if (TREE_CODE (decl) == TEMPLATE_DECL)
5282 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
5283 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
5284 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5287 /* The mangled name for the NEW_FRIEND is incorrect. The function
5288 is not a template instantiation and should not be mangled like
5289 one. Therefore, we forget the mangling here; we'll recompute it
5290 later if we need it. */
5291 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5293 SET_DECL_RTL (new_friend, NULL_RTX);
5294 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5297 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5300 tree new_friend_template_info;
5301 tree new_friend_result_template_info;
5303 int new_friend_is_defn;
5305 /* We must save some information from NEW_FRIEND before calling
5306 duplicate decls since that function will free NEW_FRIEND if
5308 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5309 new_friend_is_defn =
5310 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5311 (template_for_substitution (new_friend)))
5313 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5315 /* This declaration is a `primary' template. */
5316 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5318 new_friend_result_template_info
5319 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5322 new_friend_result_template_info = NULL_TREE;
5324 /* Make the init_value nonzero so pushdecl knows this is a defn. */
5325 if (new_friend_is_defn)
5326 DECL_INITIAL (new_friend) = error_mark_node;
5328 /* Inside pushdecl_namespace_level, we will push into the
5329 current namespace. However, the friend function should go
5330 into the namespace of the template. */
5331 ns = decl_namespace_context (new_friend);
5332 push_nested_namespace (ns);
5333 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
5334 pop_nested_namespace (ns);
5336 if (old_decl == error_mark_node)
5337 return error_mark_node;
5339 if (old_decl != new_friend)
5341 /* This new friend declaration matched an existing
5342 declaration. For example, given:
5344 template <class T> void f(T);
5345 template <class U> class C {
5346 template <class T> friend void f(T) {}
5349 the friend declaration actually provides the definition
5350 of `f', once C has been instantiated for some type. So,
5351 old_decl will be the out-of-class template declaration,
5352 while new_friend is the in-class definition.
5354 But, if `f' was called before this point, the
5355 instantiation of `f' will have DECL_TI_ARGS corresponding
5356 to `T' but not to `U', references to which might appear
5357 in the definition of `f'. Previously, the most general
5358 template for an instantiation of `f' was the out-of-class
5359 version; now it is the in-class version. Therefore, we
5360 run through all specialization of `f', adding to their
5361 DECL_TI_ARGS appropriately. In particular, they need a
5362 new set of outer arguments, corresponding to the
5363 arguments for this class instantiation.
5365 The same situation can arise with something like this:
5368 template <class T> class C {
5372 when `C<int>' is instantiated. Now, `f(int)' is defined
5375 if (!new_friend_is_defn)
5376 /* On the other hand, if the in-class declaration does
5377 *not* provide a definition, then we don't want to alter
5378 existing definitions. We can just leave everything
5383 /* Overwrite whatever template info was there before, if
5384 any, with the new template information pertaining to
5386 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5388 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5389 reregister_specialization (new_friend,
5390 most_general_template (old_decl),
5395 tree new_friend_args;
5397 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5398 = new_friend_result_template_info;
5400 new_friend_args = TI_ARGS (new_friend_template_info);
5401 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5405 tree spec = TREE_VALUE (t);
5408 = add_outermost_template_args (new_friend_args,
5409 DECL_TI_ARGS (spec));
5412 /* Now, since specializations are always supposed to
5413 hang off of the most general template, we must move
5415 t = most_general_template (old_decl);
5418 DECL_TEMPLATE_SPECIALIZATIONS (t)
5419 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5420 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5421 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5426 /* The information from NEW_FRIEND has been merged into OLD_DECL
5427 by duplicate_decls. */
5428 new_friend = old_decl;
5433 tree context = DECL_CONTEXT (new_friend);
5437 template <class T> class C {
5438 template <class U> friend void C1<U>::f (); // case 1
5439 friend void C2<T>::f (); // case 2
5441 we only need to make sure CONTEXT is a complete type for
5442 case 2. To distinguish between the two cases, we note that
5443 CONTEXT of case 1 remains dependent type after tsubst while
5444 this isn't true for case 2. */
5445 ++processing_template_decl;
5446 dependent_p = dependent_type_p (context);
5447 --processing_template_decl;
5450 && !complete_type_or_else (context, NULL_TREE))
5451 return error_mark_node;
5453 if (COMPLETE_TYPE_P (context))
5455 /* Check to see that the declaration is really present, and,
5456 possibly obtain an improved declaration. */
5457 tree fn = check_classfn (context,
5458 new_friend, NULL_TREE);
5468 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5469 template arguments, as for tsubst.
5471 Returns an appropriate tsubst'd friend type or error_mark_node on
5475 tsubst_friend_class (tree friend_tmpl, tree args)
5481 context = DECL_CONTEXT (friend_tmpl);
5485 if (TREE_CODE (context) == NAMESPACE_DECL)
5486 push_nested_namespace (context);
5488 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5491 /* Look for a class template declaration. We look for hidden names
5492 because two friend declarations of the same template are the
5493 same. For example, in:
5496 template <typename> friend class F;
5498 template <typename> struct B {
5499 template <typename> friend class F;
5502 both F templates are the same. */
5503 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
5504 /*block_p=*/true, 0,
5505 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
5507 /* But, if we don't find one, it might be because we're in a
5508 situation like this:
5516 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5517 for `S<int>', not the TEMPLATE_DECL. */
5518 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5520 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
5521 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5524 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5526 /* The friend template has already been declared. Just
5527 check to see that the declarations match, and install any new
5528 default parameters. We must tsubst the default parameters,
5529 of course. We only need the innermost template parameters
5530 because that is all that redeclare_class_template will look
5532 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5533 > TMPL_ARGS_DEPTH (args))
5536 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5537 args, tf_warning_or_error);
5538 redeclare_class_template (TREE_TYPE (tmpl), parms);
5541 friend_type = TREE_TYPE (tmpl);
5545 /* The friend template has not already been declared. In this
5546 case, the instantiation of the template class will cause the
5547 injection of this template into the global scope. */
5548 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
5549 if (tmpl == error_mark_node)
5550 return error_mark_node;
5552 /* The new TMPL is not an instantiation of anything, so we
5553 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5554 the new type because that is supposed to be the corresponding
5555 template decl, i.e., TMPL. */
5556 DECL_USE_TEMPLATE (tmpl) = 0;
5557 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5558 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5559 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5560 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5562 /* Inject this template into the global scope. */
5563 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
5568 if (TREE_CODE (context) == NAMESPACE_DECL)
5569 pop_nested_namespace (context);
5571 pop_nested_class ();
5577 /* Returns zero if TYPE cannot be completed later due to circularity.
5578 Otherwise returns one. */
5581 can_complete_type_without_circularity (tree type)
5583 if (type == NULL_TREE || type == error_mark_node)
5585 else if (COMPLETE_TYPE_P (type))
5587 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5588 return can_complete_type_without_circularity (TREE_TYPE (type));
5589 else if (CLASS_TYPE_P (type)
5590 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5597 instantiate_class_template (tree type)
5599 tree template, args, pattern, t, member;
5604 if (type == error_mark_node)
5605 return error_mark_node;
5607 if (TYPE_BEING_DEFINED (type)
5608 || COMPLETE_TYPE_P (type)
5609 || dependent_type_p (type))
5612 /* Figure out which template is being instantiated. */
5613 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5614 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
5616 /* Determine what specialization of the original template to
5618 t = most_specialized_class (type, template);
5619 if (t == error_mark_node)
5621 TYPE_BEING_DEFINED (type) = 1;
5622 return error_mark_node;
5626 /* This TYPE is actually an instantiation of a partial
5627 specialization. We replace the innermost set of ARGS with
5628 the arguments appropriate for substitution. For example,
5631 template <class T> struct S {};
5632 template <class T> struct S<T*> {};
5634 and supposing that we are instantiating S<int*>, ARGS will
5635 presently be {int*} -- but we need {int}. */
5636 pattern = TREE_TYPE (t);
5637 args = TREE_PURPOSE (t);
5641 pattern = TREE_TYPE (template);
5642 args = CLASSTYPE_TI_ARGS (type);
5645 /* If the template we're instantiating is incomplete, then clearly
5646 there's nothing we can do. */
5647 if (!COMPLETE_TYPE_P (pattern))
5650 /* If we've recursively instantiated too many templates, stop. */
5651 if (! push_tinst_level (type))
5654 /* Now we're really doing the instantiation. Mark the type as in
5655 the process of being defined. */
5656 TYPE_BEING_DEFINED (type) = 1;
5658 /* We may be in the middle of deferred access check. Disable
5660 push_deferring_access_checks (dk_no_deferred);
5662 push_to_top_level ();
5664 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5666 /* Set the input location to the template definition. This is needed
5667 if tsubsting causes an error. */
5668 typedecl = TYPE_MAIN_DECL (type);
5669 input_location = DECL_SOURCE_LOCATION (typedecl);
5670 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
5672 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5673 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5674 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5675 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5676 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5677 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5678 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5679 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5680 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5681 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5682 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5683 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5684 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5685 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5686 if (ANON_AGGR_TYPE_P (pattern))
5687 SET_ANON_AGGR_TYPE_P (type);
5688 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
5690 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
5691 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
5694 pbinfo = TYPE_BINFO (pattern);
5696 /* We should never instantiate a nested class before its enclosing
5697 class; we need to look up the nested class by name before we can
5698 instantiate it, and that lookup should instantiate the enclosing
5700 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5701 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5702 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
5704 base_list = NULL_TREE;
5705 if (BINFO_N_BASE_BINFOS (pbinfo))
5708 tree context = TYPE_CONTEXT (type);
5712 /* We must enter the scope containing the type, as that is where
5713 the accessibility of types named in dependent bases are
5715 pushed_scope = push_scope (context ? context : global_namespace);
5717 /* Substitute into each of the bases to determine the actual
5719 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
5722 tree access = BINFO_BASE_ACCESS (pbinfo, i);
5724 /* Substitute to figure out the base class. */
5725 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
5726 if (base == error_mark_node)
5729 base_list = tree_cons (access, base, base_list);
5730 if (BINFO_VIRTUAL_P (pbase_binfo))
5731 TREE_TYPE (base_list) = integer_type_node;
5734 /* The list is now in reverse order; correct that. */
5735 base_list = nreverse (base_list);
5738 pop_scope (pushed_scope);
5740 /* Now call xref_basetypes to set up all the base-class
5742 xref_basetypes (type, base_list);
5745 /* Now that our base classes are set up, enter the scope of the
5746 class, so that name lookups into base classes, etc. will work
5747 correctly. This is precisely analogous to what we do in
5748 begin_class_definition when defining an ordinary non-template
5752 /* Now members are processed in the order of declaration. */
5753 for (member = CLASSTYPE_DECL_LIST (pattern);
5754 member; member = TREE_CHAIN (member))
5756 tree t = TREE_VALUE (member);
5758 if (TREE_PURPOSE (member))
5762 /* Build new CLASSTYPE_NESTED_UTDS. */
5765 bool class_template_p;
5767 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
5768 && TYPE_LANG_SPECIFIC (t)
5769 && CLASSTYPE_IS_TEMPLATE (t));
5770 /* If the member is a class template, then -- even after
5771 substitution -- there may be dependent types in the
5772 template argument list for the class. We increment
5773 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5774 that function will assume that no types are dependent
5775 when outside of a template. */
5776 if (class_template_p)
5777 ++processing_template_decl;
5778 newtag = tsubst (t, args, tf_error, NULL_TREE);
5779 if (class_template_p)
5780 --processing_template_decl;
5781 if (newtag == error_mark_node)
5784 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5786 tree name = TYPE_IDENTIFIER (t);
5788 if (class_template_p)
5789 /* Unfortunately, lookup_template_class sets
5790 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5791 instantiation (i.e., for the type of a member
5792 template class nested within a template class.)
5793 This behavior is required for
5794 maybe_process_partial_specialization to work
5795 correctly, but is not accurate in this case;
5796 the TAG is not an instantiation of anything.
5797 (The corresponding TEMPLATE_DECL is an
5798 instantiation, but the TYPE is not.) */
5799 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5801 /* Now, we call pushtag to put this NEWTAG into the scope of
5802 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5803 pushtag calling push_template_decl. We don't have to do
5804 this for enums because it will already have been done in
5807 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5808 pushtag (name, newtag, /*tag_scope=*/ts_current);
5811 else if (TREE_CODE (t) == FUNCTION_DECL
5812 || DECL_FUNCTION_TEMPLATE_P (t))
5814 /* Build new TYPE_METHODS. */
5817 if (TREE_CODE (t) == TEMPLATE_DECL)
5818 ++processing_template_decl;
5819 r = tsubst (t, args, tf_error, NULL_TREE);
5820 if (TREE_CODE (t) == TEMPLATE_DECL)
5821 --processing_template_decl;
5822 set_current_access_from_decl (r);
5823 finish_member_declaration (r);
5827 /* Build new TYPE_FIELDS. */
5828 if (TREE_CODE (t) == STATIC_ASSERT)
5831 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
5832 tf_warning_or_error, NULL_TREE,
5833 /*integral_constant_expression_p=*/true);
5834 finish_static_assert (condition,
5835 STATIC_ASSERT_MESSAGE (t),
5836 STATIC_ASSERT_SOURCE_LOCATION (t),
5839 else if (TREE_CODE (t) != CONST_DECL)
5843 /* The the file and line for this declaration, to
5844 assist in error message reporting. Since we
5845 called push_tinst_level above, we don't need to
5847 input_location = DECL_SOURCE_LOCATION (t);
5849 if (TREE_CODE (t) == TEMPLATE_DECL)
5850 ++processing_template_decl;
5851 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
5852 if (TREE_CODE (t) == TEMPLATE_DECL)
5853 --processing_template_decl;
5854 if (TREE_CODE (r) == VAR_DECL)
5858 [t]he initialization (and any associated
5859 side-effects) of a static data member does
5860 not occur unless the static data member is
5861 itself used in a way that requires the
5862 definition of the static data member to
5865 Therefore, we do not substitute into the
5866 initialized for the static data member here. */
5867 finish_static_data_member_decl
5870 /*init_const_expr_p=*/false,
5871 /*asmspec_tree=*/NULL_TREE,
5873 if (DECL_INITIALIZED_IN_CLASS_P (r))
5874 check_static_variable_definition (r, TREE_TYPE (r));
5876 else if (TREE_CODE (r) == FIELD_DECL)
5878 /* Determine whether R has a valid type and can be
5879 completed later. If R is invalid, then it is
5880 replaced by error_mark_node so that it will not be
5881 added to TYPE_FIELDS. */
5882 tree rtype = TREE_TYPE (r);
5883 if (can_complete_type_without_circularity (rtype))
5884 complete_type (rtype);
5886 if (!COMPLETE_TYPE_P (rtype))
5888 cxx_incomplete_type_error (r, rtype);
5889 r = error_mark_node;
5893 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5894 such a thing will already have been added to the field
5895 list by tsubst_enum in finish_member_declaration in the
5896 CLASSTYPE_NESTED_UTDS case above. */
5897 if (!(TREE_CODE (r) == TYPE_DECL
5898 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5899 && DECL_ARTIFICIAL (r)))
5901 set_current_access_from_decl (r);
5902 finish_member_declaration (r);
5909 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5911 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5913 tree friend_type = t;
5914 bool adjust_processing_template_decl = false;
5916 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5918 /* template <class T> friend class C; */
5919 friend_type = tsubst_friend_class (friend_type, args);
5920 adjust_processing_template_decl = true;
5922 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
5924 /* template <class T> friend class C::D; */
5925 friend_type = tsubst (friend_type, args,
5926 tf_warning_or_error, NULL_TREE);
5927 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5928 friend_type = TREE_TYPE (friend_type);
5929 adjust_processing_template_decl = true;
5931 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
5933 /* This could be either
5937 when dependent_type_p is false or
5939 template <class U> friend class T::C;
5942 friend_type = tsubst (friend_type, args,
5943 tf_warning_or_error, NULL_TREE);
5944 /* Bump processing_template_decl for correct
5945 dependent_type_p calculation. */
5946 ++processing_template_decl;
5947 if (dependent_type_p (friend_type))
5948 adjust_processing_template_decl = true;
5949 --processing_template_decl;
5951 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
5952 && hidden_name_p (TYPE_NAME (friend_type)))
5956 where C hasn't been declared yet. Let's lookup name
5957 from namespace scope directly, bypassing any name that
5958 come from dependent base class. */
5959 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
5961 /* The call to xref_tag_from_type does injection for friend
5963 push_nested_namespace (ns);
5965 xref_tag_from_type (friend_type, NULL_TREE,
5966 /*tag_scope=*/ts_current);
5967 pop_nested_namespace (ns);
5969 else if (uses_template_parms (friend_type))
5970 /* friend class C<T>; */
5971 friend_type = tsubst (friend_type, args,
5972 tf_warning_or_error, NULL_TREE);
5977 where C is already declared or
5979 friend class C<int>;
5981 We don't have to do anything in these cases. */
5983 if (adjust_processing_template_decl)
5984 /* Trick make_friend_class into realizing that the friend
5985 we're adding is a template, not an ordinary class. It's
5986 important that we use make_friend_class since it will
5987 perform some error-checking and output cross-reference
5989 ++processing_template_decl;
5991 if (friend_type != error_mark_node)
5992 make_friend_class (type, friend_type, /*complain=*/false);
5994 if (adjust_processing_template_decl)
5995 --processing_template_decl;
5999 /* Build new DECL_FRIENDLIST. */
6002 /* The the file and line for this declaration, to
6003 assist in error message reporting. Since we
6004 called push_tinst_level above, we don't need to
6006 input_location = DECL_SOURCE_LOCATION (t);
6008 if (TREE_CODE (t) == TEMPLATE_DECL)
6010 ++processing_template_decl;
6011 push_deferring_access_checks (dk_no_check);
6014 r = tsubst_friend_function (t, args);
6015 add_friend (type, r, /*complain=*/false);
6016 if (TREE_CODE (t) == TEMPLATE_DECL)
6018 pop_deferring_access_checks ();
6019 --processing_template_decl;
6025 /* Set the file and line number information to whatever is given for
6026 the class itself. This puts error messages involving generated
6027 implicit functions at a predictable point, and the same point
6028 that would be used for non-template classes. */
6029 input_location = DECL_SOURCE_LOCATION (typedecl);
6031 unreverse_member_declarations (type);
6032 finish_struct_1 (type);
6033 TYPE_BEING_DEFINED (type) = 0;
6035 /* Now that the class is complete, instantiate default arguments for
6036 any member functions. We don't do this earlier because the
6037 default arguments may reference members of the class. */
6038 if (!PRIMARY_TEMPLATE_P (template))
6039 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
6040 if (TREE_CODE (t) == FUNCTION_DECL
6041 /* Implicitly generated member functions will not have template
6042 information; they are not instantiations, but instead are
6043 created "fresh" for each instantiation. */
6044 && DECL_TEMPLATE_INFO (t))
6045 tsubst_default_arguments (t);
6048 pop_from_top_level ();
6049 pop_deferring_access_checks ();
6052 /* The vtable for a template class can be emitted in any translation
6053 unit in which the class is instantiated. When there is no key
6054 method, however, finish_struct_1 will already have added TYPE to
6055 the keyed_classes list. */
6056 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
6057 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
6063 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6069 else if (TYPE_P (t))
6070 r = tsubst (t, args, complain, in_decl);
6073 r = tsubst_expr (t, args, complain, in_decl,
6074 /*integral_constant_expression_p=*/true);
6075 r = fold_non_dependent_expr (r);
6080 /* Substitute ARGS into the vector or list of template arguments T. */
6083 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6085 int len = TREE_VEC_LENGTH (t);
6086 int need_new = 0, i;
6087 tree *elts = (tree *) alloca (len * sizeof (tree));
6089 for (i = 0; i < len; i++)
6091 tree orig_arg = TREE_VEC_ELT (t, i);
6094 if (TREE_CODE (orig_arg) == TREE_VEC)
6095 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
6097 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
6099 if (new_arg == error_mark_node)
6100 return error_mark_node;
6103 if (new_arg != orig_arg)
6110 t = make_tree_vec (len);
6111 for (i = 0; i < len; i++)
6112 TREE_VEC_ELT (t, i) = elts[i];
6117 /* Return the result of substituting ARGS into the template parameters
6118 given by PARMS. If there are m levels of ARGS and m + n levels of
6119 PARMS, then the result will contain n levels of PARMS. For
6120 example, if PARMS is `template <class T> template <class U>
6121 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
6122 result will be `template <int*, double, class V>'. */
6125 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
6130 /* When substituting into a template, we must set
6131 PROCESSING_TEMPLATE_DECL as the template parameters may be
6132 dependent if they are based on one-another, and the dependency
6133 predicates are short-circuit outside of templates. */
6134 ++processing_template_decl;
6136 for (new_parms = &r;
6137 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
6138 new_parms = &(TREE_CHAIN (*new_parms)),
6139 parms = TREE_CHAIN (parms))
6142 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
6145 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
6151 if (parms == error_mark_node)
6154 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
6156 if (tuple == error_mark_node)
6159 default_value = TREE_PURPOSE (tuple);
6160 parm_decl = TREE_VALUE (tuple);
6162 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
6163 if (TREE_CODE (parm_decl) == PARM_DECL
6164 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
6165 parm_decl = error_mark_node;
6166 default_value = tsubst_template_arg (default_value, args,
6167 complain, NULL_TREE);
6169 tuple = build_tree_list (default_value, parm_decl);
6170 TREE_VEC_ELT (new_vec, i) = tuple;
6174 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
6175 - TMPL_ARGS_DEPTH (args)),
6176 new_vec, NULL_TREE);
6179 --processing_template_decl;
6184 /* Substitute the ARGS into the indicated aggregate (or enumeration)
6185 type T. If T is not an aggregate or enumeration type, it is
6186 handled as if by tsubst. IN_DECL is as for tsubst. If
6187 ENTERING_SCOPE is nonzero, T is the context for a template which
6188 we are presently tsubst'ing. Return the substituted value. */
6191 tsubst_aggr_type (tree t,
6193 tsubst_flags_t complain,
6200 switch (TREE_CODE (t))
6203 if (TYPE_PTRMEMFUNC_P (t))
6204 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
6206 /* Else fall through. */
6209 if (TYPE_TEMPLATE_INFO (t))
6214 bool saved_skip_evaluation;
6216 /* In "sizeof(X<I>)" we need to evaluate "I". */
6217 saved_skip_evaluation = skip_evaluation;
6218 skip_evaluation = false;
6220 /* First, determine the context for the type we are looking
6222 context = TYPE_CONTEXT (t);
6224 context = tsubst_aggr_type (context, args, complain,
6225 in_decl, /*entering_scope=*/1);
6227 /* Then, figure out what arguments are appropriate for the
6228 type we are trying to find. For example, given:
6230 template <class T> struct S;
6231 template <class T, class U> void f(T, U) { S<U> su; }
6233 and supposing that we are instantiating f<int, double>,
6234 then our ARGS will be {int, double}, but, when looking up
6235 S we only want {double}. */
6236 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
6238 if (argvec == error_mark_node)
6239 r = error_mark_node;
6242 r = lookup_template_class (t, argvec, in_decl, context,
6243 entering_scope, complain);
6244 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6247 skip_evaluation = saved_skip_evaluation;
6252 /* This is not a template type, so there's nothing to do. */
6256 return tsubst (t, args, complain, in_decl);
6260 /* Substitute into the default argument ARG (a default argument for
6261 FN), which has the indicated TYPE. */
6264 tsubst_default_argument (tree fn, tree type, tree arg)
6266 tree saved_class_ptr = NULL_TREE;
6267 tree saved_class_ref = NULL_TREE;
6269 /* This default argument came from a template. Instantiate the
6270 default argument here, not in tsubst. In the case of
6279 we must be careful to do name lookup in the scope of S<T>,
6280 rather than in the current class. */
6281 push_access_scope (fn);
6282 /* The "this" pointer is not valid in a default argument. */
6285 saved_class_ptr = current_class_ptr;
6286 cp_function_chain->x_current_class_ptr = NULL_TREE;
6287 saved_class_ref = current_class_ref;
6288 cp_function_chain->x_current_class_ref = NULL_TREE;
6291 push_deferring_access_checks(dk_no_deferred);
6292 /* The default argument expression may cause implicitly defined
6293 member functions to be synthesized, which will result in garbage
6294 collection. We must treat this situation as if we were within
6295 the body of function so as to avoid collecting live data on the
6298 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
6299 tf_warning_or_error, NULL_TREE,
6300 /*integral_constant_expression_p=*/false);
6302 pop_deferring_access_checks();
6304 /* Restore the "this" pointer. */
6307 cp_function_chain->x_current_class_ptr = saved_class_ptr;
6308 cp_function_chain->x_current_class_ref = saved_class_ref;
6311 pop_access_scope (fn);
6313 /* Make sure the default argument is reasonable. */
6314 arg = check_default_argument (type, arg);
6319 /* Substitute into all the default arguments for FN. */
6322 tsubst_default_arguments (tree fn)
6327 tmpl_args = DECL_TI_ARGS (fn);
6329 /* If this function is not yet instantiated, we certainly don't need
6330 its default arguments. */
6331 if (uses_template_parms (tmpl_args))
6334 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
6336 arg = TREE_CHAIN (arg))
6337 if (TREE_PURPOSE (arg))
6338 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
6340 TREE_PURPOSE (arg));
6343 /* Substitute the ARGS into the T, which is a _DECL. Return the
6344 result of the substitution. Issue error and warning messages under
6345 control of COMPLAIN. */
6348 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
6350 location_t saved_loc;
6354 /* Set the filename and linenumber to improve error-reporting. */
6355 saved_loc = input_location;
6356 input_location = DECL_SOURCE_LOCATION (t);
6358 switch (TREE_CODE (t))
6362 /* We can get here when processing a member function template,
6363 member class template, and template template parameter of
6364 a template class. */
6365 tree decl = DECL_TEMPLATE_RESULT (t);
6370 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
6372 /* Template template parameter is treated here. */
6373 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6374 if (new_type == error_mark_node)
6375 return error_mark_node;
6378 TREE_CHAIN (r) = NULL_TREE;
6379 TREE_TYPE (r) = new_type;
6380 DECL_TEMPLATE_RESULT (r)
6381 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
6382 DECL_TEMPLATE_PARMS (r)
6383 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6385 TYPE_NAME (new_type) = r;
6389 /* We might already have an instance of this template.
6390 The ARGS are for the surrounding class type, so the
6391 full args contain the tsubst'd args for the context,
6392 plus the innermost args from the template decl. */
6393 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
6394 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
6395 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
6396 /* Because this is a template, the arguments will still be
6397 dependent, even after substitution. If
6398 PROCESSING_TEMPLATE_DECL is not set, the dependency
6399 predicates will short-circuit. */
6400 ++processing_template_decl;
6401 full_args = tsubst_template_args (tmpl_args, args,
6403 --processing_template_decl;
6404 if (full_args == error_mark_node)
6405 return error_mark_node;
6407 /* tsubst_template_args doesn't copy the vector if
6408 nothing changed. But, *something* should have
6410 gcc_assert (full_args != tmpl_args);
6412 spec = retrieve_specialization (t, full_args,
6413 /*class_specializations_p=*/true);
6414 if (spec != NULL_TREE)
6420 /* Make a new template decl. It will be similar to the
6421 original, but will record the current template arguments.
6422 We also create a new function declaration, which is just
6423 like the old one, but points to this new template, rather
6424 than the old one. */
6426 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
6427 TREE_CHAIN (r) = NULL_TREE;
6429 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6431 if (TREE_CODE (decl) == TYPE_DECL)
6434 ++processing_template_decl;
6435 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6436 --processing_template_decl;
6437 if (new_type == error_mark_node)
6438 return error_mark_node;
6440 TREE_TYPE (r) = new_type;
6441 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6442 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6443 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6444 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
6449 ++processing_template_decl;
6450 new_decl = tsubst (decl, args, complain, in_decl);
6451 --processing_template_decl;
6452 if (new_decl == error_mark_node)
6453 return error_mark_node;
6455 DECL_TEMPLATE_RESULT (r) = new_decl;
6456 DECL_TI_TEMPLATE (new_decl) = r;
6457 TREE_TYPE (r) = TREE_TYPE (new_decl);
6458 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6459 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
6462 SET_DECL_IMPLICIT_INSTANTIATION (r);
6463 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6464 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6466 /* The template parameters for this new template are all the
6467 template parameters for the old template, except the
6468 outermost level of parameters. */
6469 DECL_TEMPLATE_PARMS (r)
6470 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6473 if (PRIMARY_TEMPLATE_P (t))
6474 DECL_PRIMARY_TEMPLATE (r) = r;
6476 if (TREE_CODE (decl) != TYPE_DECL)
6477 /* Record this non-type partial instantiation. */
6478 register_specialization (r, t,
6479 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
6487 tree argvec = NULL_TREE;
6495 /* Nobody should be tsubst'ing into non-template functions. */
6496 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
6498 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6503 /* If T is not dependent, just return it. We have to
6504 increment PROCESSING_TEMPLATE_DECL because
6505 value_dependent_expression_p assumes that nothing is
6506 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6507 ++processing_template_decl;
6508 dependent_p = value_dependent_expression_p (t);
6509 --processing_template_decl;
6513 /* Calculate the most general template of which R is a
6514 specialization, and the complete set of arguments used to
6516 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6517 argvec = tsubst_template_args (DECL_TI_ARGS
6518 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6519 args, complain, in_decl);
6521 /* Check to see if we already have this specialization. */
6522 spec = retrieve_specialization (gen_tmpl, argvec,
6523 /*class_specializations_p=*/false);
6531 /* We can see more levels of arguments than parameters if
6532 there was a specialization of a member template, like
6535 template <class T> struct S { template <class U> void f(); }
6536 template <> template <class U> void S<int>::f(U);
6538 Here, we'll be substituting into the specialization,
6539 because that's where we can find the code we actually
6540 want to generate, but we'll have enough arguments for
6541 the most general template.
6543 We also deal with the peculiar case:
6545 template <class T> struct S {
6546 template <class U> friend void f();
6548 template <class U> void f() {}
6550 template void f<double>();
6552 Here, the ARGS for the instantiation of will be {int,
6553 double}. But, we only need as many ARGS as there are
6554 levels of template parameters in CODE_PATTERN. We are
6555 careful not to get fooled into reducing the ARGS in
6558 template <class T> struct S { template <class U> void f(U); }
6559 template <class T> template <> void S<T>::f(int) {}
6561 which we can spot because the pattern will be a
6562 specialization in this case. */
6563 args_depth = TMPL_ARGS_DEPTH (args);
6565 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6566 if (args_depth > parms_depth
6567 && !DECL_TEMPLATE_SPECIALIZATION (t))
6568 args = get_innermost_template_args (args, parms_depth);
6572 /* This special case arises when we have something like this:
6574 template <class T> struct S {
6575 friend void f<int>(int, double);
6578 Here, the DECL_TI_TEMPLATE for the friend declaration
6579 will be an IDENTIFIER_NODE. We are being called from
6580 tsubst_friend_function, and we want only to create a
6581 new decl (R) with appropriate types so that we can call
6582 determine_specialization. */
6583 gen_tmpl = NULL_TREE;
6586 if (DECL_CLASS_SCOPE_P (t))
6588 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6592 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6593 complain, t, /*entering_scope=*/1);
6598 ctx = DECL_CONTEXT (t);
6600 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6601 if (type == error_mark_node)
6602 return error_mark_node;
6604 /* We do NOT check for matching decls pushed separately at this
6605 point, as they may not represent instantiations of this
6606 template, and in any case are considered separate under the
6609 DECL_USE_TEMPLATE (r) = 0;
6610 TREE_TYPE (r) = type;
6611 /* Clear out the mangled name and RTL for the instantiation. */
6612 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6613 SET_DECL_RTL (r, NULL_RTX);
6614 DECL_INITIAL (r) = NULL_TREE;
6615 DECL_CONTEXT (r) = ctx;
6617 if (member && DECL_CONV_FN_P (r))
6618 /* Type-conversion operator. Reconstruct the name, in
6619 case it's the name of one of the template's parameters. */
6620 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6622 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6624 DECL_RESULT (r) = NULL_TREE;
6626 TREE_STATIC (r) = 0;
6627 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6628 DECL_EXTERNAL (r) = 1;
6629 /* If this is an instantiation of a function with internal
6630 linkage, we already know what object file linkage will be
6631 assigned to the instantiation. */
6632 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
6633 DECL_DEFER_OUTPUT (r) = 0;
6634 TREE_CHAIN (r) = NULL_TREE;
6635 DECL_PENDING_INLINE_INFO (r) = 0;
6636 DECL_PENDING_INLINE_P (r) = 0;
6637 DECL_SAVED_TREE (r) = NULL_TREE;
6639 if (DECL_CLONED_FUNCTION (r))
6641 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6643 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6644 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6647 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6648 this in the special friend case mentioned above where
6649 GEN_TMPL is NULL. */
6652 DECL_TEMPLATE_INFO (r)
6653 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6654 SET_DECL_IMPLICIT_INSTANTIATION (r);
6655 register_specialization (r, gen_tmpl, argvec, false);
6657 /* We're not supposed to instantiate default arguments
6658 until they are called, for a template. But, for a
6661 template <class T> void f ()
6662 { extern void g(int i = T()); }
6664 we should do the substitution when the template is
6665 instantiated. We handle the member function case in
6666 instantiate_class_template since the default arguments
6667 might refer to other members of the class. */
6669 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6670 && !uses_template_parms (argvec))
6671 tsubst_default_arguments (r);
6674 DECL_TEMPLATE_INFO (r) = NULL_TREE;
6676 /* Copy the list of befriending classes. */
6677 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6679 friends = &TREE_CHAIN (*friends))
6681 *friends = copy_node (*friends);
6682 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6687 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6689 maybe_retrofit_in_chrg (r);
6690 if (DECL_CONSTRUCTOR_P (r))
6691 grok_ctor_properties (ctx, r);
6692 /* If this is an instantiation of a member template, clone it.
6693 If it isn't, that'll be handled by
6694 clone_constructors_and_destructors. */
6695 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6696 clone_function_decl (r, /*update_method_vec_p=*/0);
6698 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
6699 && !grok_op_properties (r, (complain & tf_error) != 0))
6700 return error_mark_node;
6702 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6703 SET_DECL_FRIEND_CONTEXT (r,
6704 tsubst (DECL_FRIEND_CONTEXT (t),
6705 args, complain, in_decl));
6707 /* Possibly limit visibility based on template args. */
6708 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
6709 if (DECL_VISIBILITY_SPECIFIED (t))
6711 DECL_VISIBILITY_SPECIFIED (r) = 0;
6713 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
6715 determine_visibility (r);
6724 if (DECL_TEMPLATE_PARM_P (t))
6725 SET_DECL_TEMPLATE_PARM_P (r);
6727 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6728 type = type_decays_to (type);
6729 TREE_TYPE (r) = type;
6730 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6732 if (DECL_INITIAL (r))
6734 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6735 DECL_INITIAL (r) = TREE_TYPE (r);
6737 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6741 DECL_CONTEXT (r) = NULL_TREE;
6743 if (!DECL_TEMPLATE_PARM_P (r))
6744 DECL_ARG_TYPE (r) = type_passed_as (type);
6746 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6747 complain, TREE_CHAIN (t));
6756 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6757 if (type == error_mark_node)
6758 return error_mark_node;
6759 TREE_TYPE (r) = type;
6760 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6762 /* DECL_INITIAL gives the number of bits in a bit-field. */
6764 = tsubst_expr (DECL_INITIAL (t), args,
6766 /*integral_constant_expression_p=*/true);
6767 /* We don't have to set DECL_CONTEXT here; it is set by
6768 finish_member_declaration. */
6769 TREE_CHAIN (r) = NULL_TREE;
6770 if (VOID_TYPE_P (type))
6771 error ("instantiation of %q+D as type %qT", r, type);
6776 /* We reach here only for member using decls. */
6777 if (DECL_DEPENDENT_P (t))
6779 r = do_class_using_decl
6780 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
6781 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
6783 r = error_mark_node;
6788 TREE_CHAIN (r) = NULL_TREE;
6795 tree argvec = NULL_TREE;
6796 tree gen_tmpl = NULL_TREE;
6798 tree tmpl = NULL_TREE;
6800 tree type = NULL_TREE;
6803 if (TREE_CODE (t) == TYPE_DECL)
6805 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6806 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6807 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6809 /* If this is the canonical decl, we don't have to
6810 mess with instantiations, and often we can't (for
6811 typename, template type parms and such). Note that
6812 TYPE_NAME is not correct for the above test if
6813 we've copied the type for a typedef. */
6814 r = TYPE_NAME (type);
6819 /* Check to see if we already have the specialization we
6822 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
6824 /* T is a static data member or namespace-scope entity.
6825 We have to substitute into namespace-scope variables
6826 (even though such entities are never templates) because
6829 template <class T> void f() { extern T t; }
6831 where the entity referenced is not known until
6832 instantiation time. */
6834 ctx = DECL_CONTEXT (t);
6835 if (DECL_CLASS_SCOPE_P (t))
6837 ctx = tsubst_aggr_type (ctx, args,
6839 in_decl, /*entering_scope=*/1);
6840 /* If CTX is unchanged, then T is in fact the
6841 specialization we want. That situation occurs when
6842 referencing a static data member within in its own
6843 class. We can use pointer equality, rather than
6844 same_type_p, because DECL_CONTEXT is always
6846 if (ctx == DECL_CONTEXT (t))
6852 tmpl = DECL_TI_TEMPLATE (t);
6853 gen_tmpl = most_general_template (tmpl);
6854 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6855 spec = (retrieve_specialization
6857 /*class_specializations_p=*/false));
6862 /* A local variable. */
6864 /* Subsequent calls to pushdecl will fill this in. */
6866 spec = retrieve_local_specialization (t);
6868 /* If we already have the specialization we need, there is
6869 nothing more to do. */
6876 /* Create a new node for the specialization we need. */
6878 if (TREE_CODE (r) == VAR_DECL)
6880 /* Even if the original location is out of scope, the
6881 newly substituted one is not. */
6882 DECL_DEAD_FOR_LOCAL (r) = 0;
6883 DECL_INITIALIZED_P (r) = 0;
6884 DECL_TEMPLATE_INSTANTIATED (r) = 0;
6885 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6886 if (type == error_mark_node)
6887 return error_mark_node;
6888 if (TREE_CODE (type) == FUNCTION_TYPE)
6890 /* It may seem that this case cannot occur, since:
6895 declares a function, not a variable. However:
6898 template <typename T> void g() { T t; }
6899 template void g<f>();
6901 is an attempt to declare a variable with function
6903 error ("variable %qD has function type",
6904 /* R is not yet sufficiently initialized, so we
6905 just use its name. */
6907 return error_mark_node;
6909 type = complete_type (type);
6910 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6911 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6912 type = check_var_type (DECL_NAME (r), type);
6914 if (DECL_HAS_VALUE_EXPR_P (t))
6916 tree ve = DECL_VALUE_EXPR (t);
6917 ve = tsubst_expr (ve, args, complain, in_decl,
6918 /*constant_expression_p=*/false);
6919 SET_DECL_VALUE_EXPR (r, ve);
6922 else if (DECL_SELF_REFERENCE_P (t))
6923 SET_DECL_SELF_REFERENCE_P (r);
6924 TREE_TYPE (r) = type;
6925 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6926 DECL_CONTEXT (r) = ctx;
6927 /* Clear out the mangled name and RTL for the instantiation. */
6928 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6929 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
6930 SET_DECL_RTL (r, NULL_RTX);
6931 /* The initializer must not be expanded until it is required;
6933 DECL_INITIAL (r) = NULL_TREE;
6934 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
6935 SET_DECL_RTL (r, NULL_RTX);
6936 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
6937 if (TREE_CODE (r) == VAR_DECL)
6939 /* Possibly limit visibility based on template args. */
6940 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
6941 if (DECL_VISIBILITY_SPECIFIED (t))
6943 DECL_VISIBILITY_SPECIFIED (r) = 0;
6945 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
6947 determine_visibility (r);
6952 /* A static data member declaration is always marked
6953 external when it is declared in-class, even if an
6954 initializer is present. We mimic the non-template
6956 DECL_EXTERNAL (r) = 1;
6958 register_specialization (r, gen_tmpl, argvec, false);
6959 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
6960 SET_DECL_IMPLICIT_INSTANTIATION (r);
6963 register_local_specialization (r, t);
6965 TREE_CHAIN (r) = NULL_TREE;
6974 /* Restore the file and line information. */
6975 input_location = saved_loc;
6980 /* Substitute into the ARG_TYPES of a function type. */
6983 tsubst_arg_types (tree arg_types,
6985 tsubst_flags_t complain,
6988 tree remaining_arg_types;
6991 tree result = NULL_TREE;
6993 if (!arg_types || arg_types == void_list_node)
6996 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
6997 args, complain, in_decl);
6998 if (remaining_arg_types == error_mark_node)
6999 return error_mark_node;
7001 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
7002 if (type == error_mark_node)
7003 return error_mark_node;
7004 if (VOID_TYPE_P (type))
7006 if (complain & tf_error)
7008 error ("invalid parameter type %qT", type);
7010 error ("in declaration %q+D", in_decl);
7012 return error_mark_node;
7015 /* Do array-to-pointer, function-to-pointer conversion, and ignore
7016 top-level qualifiers as required. */
7017 type = TYPE_MAIN_VARIANT (type_decays_to (type));
7019 /* We do not substitute into default arguments here. The standard
7020 mandates that they be instantiated only when needed, which is
7021 done in build_over_call. */
7022 default_arg = TREE_PURPOSE (arg_types);
7024 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
7026 /* We've instantiated a template before its default arguments
7027 have been parsed. This can happen for a nested template
7028 class, and is not an error unless we require the default
7029 argument in a call of this function. */
7030 result = tree_cons (default_arg, type, remaining_arg_types);
7031 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg), result);
7034 result = hash_tree_cons (default_arg, type, remaining_arg_types);
7039 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
7040 *not* handle the exception-specification for FNTYPE, because the
7041 initial substitution of explicitly provided template parameters
7042 during argument deduction forbids substitution into the
7043 exception-specification:
7047 All references in the function type of the function template to the
7048 corresponding template parameters are replaced by the specified tem-
7049 plate argument values. If a substitution in a template parameter or
7050 in the function type of the function template results in an invalid
7051 type, type deduction fails. [Note: The equivalent substitution in
7052 exception specifications is done only when the function is instanti-
7053 ated, at which point a program is ill-formed if the substitution
7054 results in an invalid type.] */
7057 tsubst_function_type (tree t,
7059 tsubst_flags_t complain,
7066 /* The TYPE_CONTEXT is not used for function/method types. */
7067 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
7069 /* Substitute the return type. */
7070 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7071 if (return_type == error_mark_node)
7072 return error_mark_node;
7073 /* The standard does not presently indicate that creation of a
7074 function type with an invalid return type is a deduction failure.
7075 However, that is clearly analogous to creating an array of "void"
7076 or a reference to a reference. This is core issue #486. */
7077 if (TREE_CODE (return_type) == ARRAY_TYPE
7078 || TREE_CODE (return_type) == FUNCTION_TYPE)
7080 if (complain & tf_error)
7082 if (TREE_CODE (return_type) == ARRAY_TYPE)
7083 error ("function returning an array");
7085 error ("function returning a function");
7087 return error_mark_node;
7090 /* Substitute the argument types. */
7091 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
7093 if (arg_types == error_mark_node)
7094 return error_mark_node;
7096 if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED
7097 && in_decl != NULL_TREE
7098 && !TREE_NO_WARNING (in_decl)
7099 && (SCALAR_TYPE_P (return_type) || VOID_TYPE_P (return_type)))
7100 warning (OPT_Wreturn_type,
7101 "type qualifiers ignored on function return type");
7103 /* Construct a new type node and return it. */
7104 if (TREE_CODE (t) == FUNCTION_TYPE)
7105 fntype = build_function_type (return_type, arg_types);
7108 tree r = TREE_TYPE (TREE_VALUE (arg_types));
7109 if (! IS_AGGR_TYPE (r))
7113 Type deduction may fail for any of the following
7116 -- Attempting to create "pointer to member of T" when T
7117 is not a class type. */
7118 if (complain & tf_error)
7119 error ("creating pointer to member function of non-class type %qT",
7121 return error_mark_node;
7124 fntype = build_method_type_directly (r, return_type,
7125 TREE_CHAIN (arg_types));
7127 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
7128 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
7133 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
7134 ARGS into that specification, and return the substituted
7135 specification. If there is no specification, return NULL_TREE. */
7138 tsubst_exception_specification (tree fntype,
7140 tsubst_flags_t complain,
7146 specs = TYPE_RAISES_EXCEPTIONS (fntype);
7147 new_specs = NULL_TREE;
7150 if (! TREE_VALUE (specs))
7156 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
7157 if (spec == error_mark_node)
7159 new_specs = add_exception_specifier (new_specs, spec, complain);
7160 specs = TREE_CHAIN (specs);
7166 /* Take the tree structure T and replace template parameters used
7167 therein with the argument vector ARGS. IN_DECL is an associated
7168 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
7169 Issue error and warning messages under control of COMPLAIN. Note
7170 that we must be relatively non-tolerant of extensions here, in
7171 order to preserve conformance; if we allow substitutions that
7172 should not be allowed, we may allow argument deductions that should
7173 not succeed, and therefore report ambiguous overload situations
7174 where there are none. In theory, we could allow the substitution,
7175 but indicate that it should have failed, and allow our caller to
7176 make sure that the right thing happens, but we don't try to do this
7179 This function is used for dealing with types, decls and the like;
7180 for expressions, use tsubst_expr or tsubst_copy. */
7183 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7187 if (t == NULL_TREE || t == error_mark_node
7188 || t == integer_type_node
7189 || t == void_type_node
7190 || t == char_type_node
7191 || t == unknown_type_node
7192 || TREE_CODE (t) == NAMESPACE_DECL)
7196 return tsubst_decl (t, args, complain);
7198 if (TREE_CODE (t) == IDENTIFIER_NODE)
7199 type = IDENTIFIER_TYPE_VALUE (t);
7201 type = TREE_TYPE (t);
7203 gcc_assert (type != unknown_type_node);
7206 && TREE_CODE (t) != TYPENAME_TYPE
7207 && TREE_CODE (t) != IDENTIFIER_NODE
7208 && TREE_CODE (t) != FUNCTION_TYPE
7209 && TREE_CODE (t) != METHOD_TYPE)
7210 type = tsubst (type, args, complain, in_decl);
7211 if (type == error_mark_node)
7212 return error_mark_node;
7214 switch (TREE_CODE (t))
7219 return tsubst_aggr_type (t, args, complain, in_decl,
7220 /*entering_scope=*/0);
7223 case IDENTIFIER_NODE:
7235 if (t == integer_type_node)
7238 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
7239 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
7243 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
7245 max = tsubst_expr (omax, args, complain, in_decl,
7246 /*integral_constant_expression_p=*/false);
7247 max = fold_decl_constant_value (max);
7249 if (TREE_CODE (max) != INTEGER_CST
7250 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
7251 && !at_function_scope_p ())
7253 if (complain & tf_error)
7254 error ("array bound is not an integer constant");
7255 return error_mark_node;
7260 Type deduction may fail for any of the following
7263 Attempting to create an array with a size that is
7264 zero or negative. */
7265 if (integer_zerop (max) && !(complain & tf_error))
7266 /* We must fail if performing argument deduction (as
7267 indicated by the state of complain), so that
7268 another substitution can be found. */
7269 return error_mark_node;
7270 else if (TREE_CODE (max) == INTEGER_CST
7271 && INT_CST_LT (max, integer_zero_node))
7273 if (complain & tf_error)
7274 error ("creating array with negative size (%qE)", max);
7276 return error_mark_node;
7279 return compute_array_index_type (NULL_TREE, max);
7282 case TEMPLATE_TYPE_PARM:
7283 case TEMPLATE_TEMPLATE_PARM:
7284 case BOUND_TEMPLATE_TEMPLATE_PARM:
7285 case TEMPLATE_PARM_INDEX:
7290 tree arg = NULL_TREE;
7294 gcc_assert (TREE_VEC_LENGTH (args) > 0);
7295 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7296 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
7297 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7299 idx = TEMPLATE_TYPE_IDX (t);
7300 level = TEMPLATE_TYPE_LEVEL (t);
7304 idx = TEMPLATE_PARM_IDX (t);
7305 level = TEMPLATE_PARM_LEVEL (t);
7308 levels = TMPL_ARGS_DEPTH (args);
7309 if (level <= levels)
7310 arg = TMPL_ARG (args, level, idx);
7312 if (arg == error_mark_node)
7313 return error_mark_node;
7314 else if (arg != NULL_TREE)
7316 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
7319 gcc_assert (TYPE_P (arg));
7321 /* cv-quals from the template are discarded when
7322 substituting in a function or reference type. */
7323 if (TREE_CODE (arg) == FUNCTION_TYPE
7324 || TREE_CODE (arg) == METHOD_TYPE
7325 || TREE_CODE (arg) == REFERENCE_TYPE)
7326 quals = cp_type_quals (arg);
7328 quals = cp_type_quals (arg) | cp_type_quals (t);
7330 return cp_build_qualified_type_real
7331 (arg, quals, complain | tf_ignore_bad_quals);
7333 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7335 /* We are processing a type constructed from a
7336 template template parameter. */
7337 tree argvec = tsubst (TYPE_TI_ARGS (t),
7338 args, complain, in_decl);
7339 if (argvec == error_mark_node)
7340 return error_mark_node;
7342 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
7343 are resolving nested-types in the signature of a
7344 member function templates. Otherwise ARG is a
7345 TEMPLATE_DECL and is the real template to be
7347 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
7348 arg = TYPE_NAME (arg);
7350 r = lookup_template_class (arg,
7353 /*entering_scope=*/0,
7355 return cp_build_qualified_type_real
7356 (r, TYPE_QUALS (t), complain);
7359 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
7364 /* This can happen during the attempted tsubst'ing in
7365 unify. This means that we don't yet have any information
7366 about the template parameter in question. */
7369 /* If we get here, we must have been looking at a parm for a
7370 more deeply nested template. Make a new version of this
7371 template parameter, but with a lower level. */
7372 switch (TREE_CODE (t))
7374 case TEMPLATE_TYPE_PARM:
7375 case TEMPLATE_TEMPLATE_PARM:
7376 case BOUND_TEMPLATE_TEMPLATE_PARM:
7377 if (cp_type_quals (t))
7379 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
7380 r = cp_build_qualified_type_real
7381 (r, cp_type_quals (t),
7382 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7383 ? tf_ignore_bad_quals : 0));
7388 TEMPLATE_TYPE_PARM_INDEX (r)
7389 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
7391 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
7392 TYPE_MAIN_VARIANT (r) = r;
7393 TYPE_POINTER_TO (r) = NULL_TREE;
7394 TYPE_REFERENCE_TO (r) = NULL_TREE;
7396 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
7397 /* We have reduced the level of the template
7398 template parameter, but not the levels of its
7399 template parameters, so canonical_type_parameter
7400 will not be able to find the canonical template
7401 template parameter for this level. Thus, we
7402 require structural equality checking to compare
7403 TEMPLATE_TEMPLATE_PARMs. */
7404 SET_TYPE_STRUCTURAL_EQUALITY (r);
7405 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
7406 SET_TYPE_STRUCTURAL_EQUALITY (r);
7408 TYPE_CANONICAL (r) = canonical_type_parameter (r);
7410 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7412 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
7414 if (argvec == error_mark_node)
7415 return error_mark_node;
7417 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
7418 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
7423 case TEMPLATE_PARM_INDEX:
7424 r = reduce_template_parm_level (t, type, levels);
7436 tree purpose, value, chain;
7438 if (t == void_list_node)
7441 purpose = TREE_PURPOSE (t);
7444 purpose = tsubst (purpose, args, complain, in_decl);
7445 if (purpose == error_mark_node)
7446 return error_mark_node;
7448 value = TREE_VALUE (t);
7451 value = tsubst (value, args, complain, in_decl);
7452 if (value == error_mark_node)
7453 return error_mark_node;
7455 chain = TREE_CHAIN (t);
7456 if (chain && chain != void_type_node)
7458 chain = tsubst (chain, args, complain, in_decl);
7459 if (chain == error_mark_node)
7460 return error_mark_node;
7462 if (purpose == TREE_PURPOSE (t)
7463 && value == TREE_VALUE (t)
7464 && chain == TREE_CHAIN (t))
7466 return hash_tree_cons (purpose, value, chain);
7470 /* We should never be tsubsting a binfo. */
7474 /* A vector of template arguments. */
7476 return tsubst_template_args (t, args, complain, in_decl);
7479 case REFERENCE_TYPE:
7481 enum tree_code code;
7483 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
7486 code = TREE_CODE (t);
7491 Type deduction may fail for any of the following
7494 -- Attempting to create a pointer to reference type.
7495 -- Attempting to create a reference to a reference type or
7496 a reference to void. */
7497 if (TREE_CODE (type) == REFERENCE_TYPE
7498 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
7500 static location_t last_loc;
7502 /* We keep track of the last time we issued this error
7503 message to avoid spewing a ton of messages during a
7504 single bad template instantiation. */
7505 if (complain & tf_error
7506 #ifdef USE_MAPPED_LOCATION
7507 && last_loc != input_location
7509 && (last_loc.line != input_line
7510 || last_loc.file != input_filename)
7514 if (TREE_CODE (type) == VOID_TYPE)
7515 error ("forming reference to void");
7517 error ("forming %s to reference type %qT",
7518 (code == POINTER_TYPE) ? "pointer" : "reference",
7520 last_loc = input_location;
7523 return error_mark_node;
7525 else if (code == POINTER_TYPE)
7527 r = build_pointer_type (type);
7528 if (TREE_CODE (type) == METHOD_TYPE)
7529 r = build_ptrmemfunc_type (r);
7532 r = build_reference_type (type);
7533 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7535 if (r != error_mark_node)
7536 /* Will this ever be needed for TYPE_..._TO values? */
7543 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7544 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7548 Type deduction may fail for any of the following
7551 -- Attempting to create "pointer to member of T" when T
7552 is not a class type. */
7553 if (complain & tf_error)
7554 error ("creating pointer to member of non-class type %qT", r);
7555 return error_mark_node;
7557 if (TREE_CODE (type) == REFERENCE_TYPE)
7559 if (complain & tf_error)
7560 error ("creating pointer to member reference type %qT", type);
7561 return error_mark_node;
7563 if (TREE_CODE (type) == VOID_TYPE)
7565 if (complain & tf_error)
7566 error ("creating pointer to member of type void");
7567 return error_mark_node;
7569 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
7570 if (TREE_CODE (type) == FUNCTION_TYPE)
7572 /* The type of the implicit object parameter gets its
7573 cv-qualifiers from the FUNCTION_TYPE. */
7575 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
7576 cp_type_quals (type));
7578 method_type = build_method_type_directly (this_type,
7580 TYPE_ARG_TYPES (type));
7581 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
7582 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
7586 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7595 fntype = tsubst_function_type (t, args, complain, in_decl);
7596 if (fntype == error_mark_node)
7597 return error_mark_node;
7599 /* Substitute the exception specification. */
7600 specs = tsubst_exception_specification (t, args, complain,
7602 if (specs == error_mark_node)
7603 return error_mark_node;
7605 fntype = build_exception_variant (fntype, specs);
7610 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7611 if (domain == error_mark_node)
7612 return error_mark_node;
7614 /* As an optimization, we avoid regenerating the array type if
7615 it will obviously be the same as T. */
7616 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7619 /* These checks should match the ones in grokdeclarator.
7623 The deduction may fail for any of the following reasons:
7625 -- Attempting to create an array with an element type that
7626 is void, a function type, or a reference type, or [DR337]
7627 an abstract class type. */
7628 if (TREE_CODE (type) == VOID_TYPE
7629 || TREE_CODE (type) == FUNCTION_TYPE
7630 || TREE_CODE (type) == REFERENCE_TYPE)
7632 if (complain & tf_error)
7633 error ("creating array of %qT", type);
7634 return error_mark_node;
7636 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7638 if (complain & tf_error)
7639 error ("creating array of %qT, which is an abstract class type",
7641 return error_mark_node;
7644 r = build_cplus_array_type (type, domain);
7651 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7652 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7654 if (e1 == error_mark_node || e2 == error_mark_node)
7655 return error_mark_node;
7657 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
7663 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7664 if (e == error_mark_node)
7665 return error_mark_node;
7667 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
7672 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7673 in_decl, /*entering_scope=*/1);
7674 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7677 if (ctx == error_mark_node || f == error_mark_node)
7678 return error_mark_node;
7680 if (!IS_AGGR_TYPE (ctx))
7682 if (complain & tf_error)
7683 error ("%qT is not a class, struct, or union type", ctx);
7684 return error_mark_node;
7686 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7688 /* Normally, make_typename_type does not require that the CTX
7689 have complete type in order to allow things like:
7691 template <class T> struct S { typename S<T>::X Y; };
7693 But, such constructs have already been resolved by this
7694 point, so here CTX really should have complete type, unless
7695 it's a partial instantiation. */
7696 ctx = complete_type (ctx);
7697 if (!COMPLETE_TYPE_P (ctx))
7699 if (complain & tf_error)
7700 cxx_incomplete_type_error (NULL_TREE, ctx);
7701 return error_mark_node;
7705 f = make_typename_type (ctx, f, typename_type,
7706 (complain & tf_error) | tf_keep_type_decl);
7707 if (f == error_mark_node)
7709 if (TREE_CODE (f) == TYPE_DECL)
7711 complain |= tf_ignore_bad_quals;
7715 if (TREE_CODE (f) != TYPENAME_TYPE)
7717 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
7718 error ("%qT resolves to %qT, which is not an enumeration type",
7720 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
7721 error ("%qT resolves to %qT, which is is not a class type",
7725 return cp_build_qualified_type_real
7726 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7729 case UNBOUND_CLASS_TEMPLATE:
7731 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7732 in_decl, /*entering_scope=*/1);
7733 tree name = TYPE_IDENTIFIER (t);
7734 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
7736 if (ctx == error_mark_node || name == error_mark_node)
7737 return error_mark_node;
7740 parm_list = tsubst_template_parms (parm_list, args, complain);
7741 return make_unbound_class_template (ctx, name, parm_list, complain);
7751 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7752 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
7753 /*integral_constant_expression_p=*/false);
7754 if (e1 == error_mark_node || e2 == error_mark_node)
7755 return error_mark_node;
7757 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
7762 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7763 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7764 if (e1 == error_mark_node || e2 == error_mark_node)
7765 return error_mark_node;
7767 return build_qualified_name (/*type=*/NULL_TREE,
7768 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
7775 type = finish_typeof (tsubst_expr
7776 (TYPEOF_TYPE_EXPR (t), args,
7778 /*integral_constant_expression_p=*/false));
7779 return cp_build_qualified_type_real (type,
7781 | cp_type_quals (type),
7786 sorry ("use of %qs in template",
7787 tree_code_name [(int) TREE_CODE (t)]);
7788 return error_mark_node;
7792 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7793 type of the expression on the left-hand side of the "." or "->"
7797 tsubst_baselink (tree baselink, tree object_type,
7798 tree args, tsubst_flags_t complain, tree in_decl)
7801 tree qualifying_scope;
7804 tree template_args = 0;
7805 bool template_id_p = false;
7807 /* A baselink indicates a function from a base class. Both the
7808 BASELINK_ACCESS_BINFO and the base class referenced may
7809 indicate bases of the template class, rather than the
7810 instantiated class. In addition, lookups that were not
7811 ambiguous before may be ambiguous now. Therefore, we perform
7812 the lookup again. */
7813 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7814 qualifying_scope = tsubst (qualifying_scope, args,
7816 fns = BASELINK_FUNCTIONS (baselink);
7817 optype = BASELINK_OPTYPE (baselink);
7818 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7820 template_id_p = true;
7821 template_args = TREE_OPERAND (fns, 1);
7822 fns = TREE_OPERAND (fns, 0);
7824 template_args = tsubst_template_args (template_args, args,
7827 name = DECL_NAME (get_first_fn (fns));
7828 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7830 /* If lookup found a single function, mark it as used at this
7831 point. (If it lookup found multiple functions the one selected
7832 later by overload resolution will be marked as used at that
7834 if (BASELINK_P (baselink))
7835 fns = BASELINK_FUNCTIONS (baselink);
7836 if (!template_id_p && !really_overloaded_fn (fns))
7837 mark_used (OVL_CURRENT (fns));
7839 /* Add back the template arguments, if present. */
7840 if (BASELINK_P (baselink) && template_id_p)
7841 BASELINK_FUNCTIONS (baselink)
7842 = build_nt (TEMPLATE_ID_EXPR,
7843 BASELINK_FUNCTIONS (baselink),
7845 /* Update the conversion operator type. */
7846 BASELINK_OPTYPE (baselink)
7847 = tsubst (optype, args, complain, in_decl);
7850 object_type = current_class_type;
7851 return adjust_result_of_qualified_name_lookup (baselink,
7856 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7857 true if the qualified-id will be a postfix-expression in-and-of
7858 itself; false if more of the postfix-expression follows the
7859 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7863 tsubst_qualified_id (tree qualified_id, tree args,
7864 tsubst_flags_t complain, tree in_decl,
7865 bool done, bool address_p)
7873 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
7875 /* Figure out what name to look up. */
7876 name = TREE_OPERAND (qualified_id, 1);
7877 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7880 template_args = TREE_OPERAND (name, 1);
7882 template_args = tsubst_template_args (template_args, args,
7884 name = TREE_OPERAND (name, 0);
7888 is_template = false;
7889 template_args = NULL_TREE;
7892 /* Substitute into the qualifying scope. When there are no ARGS, we
7893 are just trying to simplify a non-dependent expression. In that
7894 case the qualifying scope may be dependent, and, in any case,
7895 substituting will not help. */
7896 scope = TREE_OPERAND (qualified_id, 0);
7899 scope = tsubst (scope, args, complain, in_decl);
7900 expr = tsubst_copy (name, args, complain, in_decl);
7905 if (dependent_type_p (scope))
7906 return build_qualified_name (/*type=*/NULL_TREE,
7908 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
7910 if (!BASELINK_P (name) && !DECL_P (expr))
7912 if (TREE_CODE (expr) == BIT_NOT_EXPR)
7913 /* If this were actually a destructor call, it would have been
7914 parsed as such by the parser. */
7915 expr = error_mark_node;
7917 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7918 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7919 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7921 if (complain & tf_error)
7923 error ("dependent-name %qE is parsed as a non-type, but "
7924 "instantiation yields a type", qualified_id);
7925 inform ("say %<typename %E%> if a type is meant", qualified_id);
7927 return error_mark_node;
7933 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7935 /* Remember that there was a reference to this entity. */
7939 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
7941 if (complain & tf_error)
7942 qualified_name_lookup_error (scope,
7943 TREE_OPERAND (qualified_id, 1),
7945 return error_mark_node;
7949 expr = lookup_template_function (expr, template_args);
7951 if (expr == error_mark_node && complain & tf_error)
7952 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
7954 else if (TYPE_P (scope))
7956 expr = (adjust_result_of_qualified_name_lookup
7957 (expr, scope, current_class_type));
7958 expr = (finish_qualified_id_expr
7959 (scope, expr, done, address_p,
7960 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
7961 /*template_arg_p=*/false));
7964 /* Expressions do not generally have reference type. */
7965 if (TREE_CODE (expr) != SCOPE_REF
7966 /* However, if we're about to form a pointer-to-member, we just
7967 want the referenced member referenced. */
7968 && TREE_CODE (expr) != OFFSET_REF)
7969 expr = convert_from_reference (expr);
7974 /* Like tsubst, but deals with expressions. This function just replaces
7975 template parms; to finish processing the resultant expression, use
7979 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7981 enum tree_code code;
7984 if (t == NULL_TREE || t == error_mark_node)
7987 code = TREE_CODE (t);
7992 r = retrieve_local_specialization (t);
7993 gcc_assert (r != NULL);
8002 if (DECL_TEMPLATE_PARM_P (t))
8003 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
8004 /* There is no need to substitute into namespace-scope
8006 if (DECL_NAMESPACE_SCOPE_P (t))
8008 /* If ARGS is NULL, then T is known to be non-dependent. */
8009 if (args == NULL_TREE)
8010 return integral_constant_value (t);
8012 /* Unfortunately, we cannot just call lookup_name here.
8015 template <int I> int f() {
8017 struct S { void g() { E e = a; } };
8020 When we instantiate f<7>::S::g(), say, lookup_name is not
8021 clever enough to find f<7>::a. */
8023 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
8024 /*entering_scope=*/0);
8026 for (v = TYPE_VALUES (enum_type);
8029 if (TREE_PURPOSE (v) == DECL_NAME (t))
8030 return TREE_VALUE (v);
8032 /* We didn't find the name. That should never happen; if
8033 name-lookup found it during preliminary parsing, we
8034 should find it again here during instantiation. */
8040 if (DECL_CONTEXT (t))
8044 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
8045 /*entering_scope=*/1);
8046 if (ctx != DECL_CONTEXT (t))
8048 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
8051 if (complain & tf_error)
8052 error ("using invalid field %qD", t);
8053 return error_mark_node;
8063 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
8064 || local_variable_p (t))
8065 t = tsubst (t, args, complain, in_decl);
8070 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
8073 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8074 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
8075 args, complain, in_decl);
8076 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
8077 return tsubst (t, args, complain, in_decl);
8078 else if (DECL_CLASS_SCOPE_P (t)
8079 && uses_template_parms (DECL_CONTEXT (t)))
8081 /* Template template argument like the following example need
8084 template <template <class> class TT> struct C {};
8085 template <class T> struct D {
8086 template <class U> struct E {};
8091 We are processing the template argument `E' in #1 for
8092 the template instantiation #2. Originally, `E' is a
8093 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
8094 have to substitute this with one having context `D<int>'. */
8096 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
8097 return lookup_field (context, DECL_NAME(t), 0, false);
8100 /* Ordinary template template argument. */
8104 case REINTERPRET_CAST_EXPR:
8105 case CONST_CAST_EXPR:
8106 case STATIC_CAST_EXPR:
8107 case DYNAMIC_CAST_EXPR:
8110 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8111 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8115 case TRUTH_NOT_EXPR:
8118 case UNARY_PLUS_EXPR: /* Unary + */
8127 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
8128 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
8135 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
8136 name = TREE_OPERAND (t, 1);
8137 if (TREE_CODE (name) == BIT_NOT_EXPR)
8139 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8141 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8143 else if (TREE_CODE (name) == SCOPE_REF
8144 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
8146 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
8148 name = TREE_OPERAND (name, 1);
8149 name = tsubst_copy (TREE_OPERAND (name, 0), args,
8151 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
8152 name = build_qualified_name (/*type=*/NULL_TREE,
8154 /*template_p=*/false);
8156 else if (TREE_CODE (name) == BASELINK)
8157 name = tsubst_baselink (name,
8158 non_reference (TREE_TYPE (object)),
8162 name = tsubst_copy (name, args, complain, in_decl);
8163 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
8169 case TRUNC_DIV_EXPR:
8171 case FLOOR_DIV_EXPR:
8172 case ROUND_DIV_EXPR:
8173 case EXACT_DIV_EXPR:
8177 case TRUNC_MOD_EXPR:
8178 case FLOOR_MOD_EXPR:
8179 case TRUTH_ANDIF_EXPR:
8180 case TRUTH_ORIF_EXPR:
8181 case TRUTH_AND_EXPR:
8198 case PREDECREMENT_EXPR:
8199 case PREINCREMENT_EXPR:
8200 case POSTDECREMENT_EXPR:
8201 case POSTINCREMENT_EXPR:
8203 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8204 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8207 return build_qualified_name (/*type=*/NULL_TREE,
8208 tsubst_copy (TREE_OPERAND (t, 0),
8209 args, complain, in_decl),
8210 tsubst_copy (TREE_OPERAND (t, 1),
8211 args, complain, in_decl),
8212 QUALIFIED_NAME_IS_TEMPLATE (t));
8217 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8218 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8219 NULL_TREE, NULL_TREE);
8223 int n = VL_EXP_OPERAND_LENGTH (t);
8224 tree result = build_vl_exp (CALL_EXPR, n);
8226 for (i = 0; i < n; i++)
8227 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
8234 case PSEUDO_DTOR_EXPR:
8237 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8238 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8239 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8240 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
8247 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8248 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
8249 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
8250 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
8257 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
8258 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
8259 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
8260 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
8264 case TEMPLATE_ID_EXPR:
8266 /* Substituted template arguments */
8267 tree fn = TREE_OPERAND (t, 0);
8268 tree targs = TREE_OPERAND (t, 1);
8270 fn = tsubst_copy (fn, args, complain, in_decl);
8272 targs = tsubst_template_args (targs, args, complain, in_decl);
8274 return lookup_template_function (fn, targs);
8279 tree purpose, value, chain;
8281 if (t == void_list_node)
8284 purpose = TREE_PURPOSE (t);
8286 purpose = tsubst_copy (purpose, args, complain, in_decl);
8287 value = TREE_VALUE (t);
8289 value = tsubst_copy (value, args, complain, in_decl);
8290 chain = TREE_CHAIN (t);
8291 if (chain && chain != void_type_node)
8292 chain = tsubst_copy (chain, args, complain, in_decl);
8293 if (purpose == TREE_PURPOSE (t)
8294 && value == TREE_VALUE (t)
8295 && chain == TREE_CHAIN (t))
8297 return tree_cons (purpose, value, chain);
8304 case TEMPLATE_TYPE_PARM:
8305 case TEMPLATE_TEMPLATE_PARM:
8306 case BOUND_TEMPLATE_TEMPLATE_PARM:
8307 case TEMPLATE_PARM_INDEX:
8309 case REFERENCE_TYPE:
8315 case UNBOUND_CLASS_TEMPLATE:
8318 return tsubst (t, args, complain, in_decl);
8320 case IDENTIFIER_NODE:
8321 if (IDENTIFIER_TYPENAME_P (t))
8323 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8324 return mangle_conv_op_name_for_type (new_type);
8330 /* This is handled by tsubst_copy_and_build. */
8334 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
8336 tsubst (TREE_TYPE (t), args, complain, in_decl));
8338 case CLEANUP_POINT_EXPR:
8339 /* We shouldn't have built any of these during initial template
8340 generation. Instead, they should be built during instantiation
8341 in response to the saved STMT_IS_FULL_EXPR_P setting. */
8345 mark_used (TREE_OPERAND (t, 1));
8353 /* Like tsubst_copy, but specifically for OpenMP clauses. */
8356 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
8359 tree new_clauses = NULL, nc, oc;
8361 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
8363 nc = copy_node (oc);
8364 OMP_CLAUSE_CHAIN (nc) = new_clauses;
8367 switch (OMP_CLAUSE_CODE (nc))
8369 case OMP_CLAUSE_PRIVATE:
8370 case OMP_CLAUSE_SHARED:
8371 case OMP_CLAUSE_FIRSTPRIVATE:
8372 case OMP_CLAUSE_LASTPRIVATE:
8373 case OMP_CLAUSE_REDUCTION:
8374 case OMP_CLAUSE_COPYIN:
8375 case OMP_CLAUSE_COPYPRIVATE:
8377 case OMP_CLAUSE_NUM_THREADS:
8378 case OMP_CLAUSE_SCHEDULE:
8379 OMP_CLAUSE_OPERAND (nc, 0)
8380 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
8381 in_decl, /*integral_constant_expression_p=*/false);
8383 case OMP_CLAUSE_NOWAIT:
8384 case OMP_CLAUSE_ORDERED:
8385 case OMP_CLAUSE_DEFAULT:
8392 return finish_omp_clauses (nreverse (new_clauses));
8395 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
8398 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
8401 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
8403 tree purpose, value, chain;
8408 if (TREE_CODE (t) != TREE_LIST)
8409 return tsubst_copy_and_build (t, args, complain, in_decl,
8410 /*function_p=*/false,
8411 /*integral_constant_expression_p=*/false);
8413 if (t == void_list_node)
8416 purpose = TREE_PURPOSE (t);
8418 purpose = RECUR (purpose);
8419 value = TREE_VALUE (t);
8421 value = RECUR (value);
8422 chain = TREE_CHAIN (t);
8423 if (chain && chain != void_type_node)
8424 chain = RECUR (chain);
8425 return tree_cons (purpose, value, chain);
8429 /* Like tsubst_copy for expressions, etc. but also does semantic
8433 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
8434 bool integral_constant_expression_p)
8436 #define RECUR(NODE) \
8437 tsubst_expr ((NODE), args, complain, in_decl, \
8438 integral_constant_expression_p)
8442 if (t == NULL_TREE || t == error_mark_node)
8445 if (EXPR_HAS_LOCATION (t))
8446 input_location = EXPR_LOCATION (t);
8447 if (STATEMENT_CODE_P (TREE_CODE (t)))
8448 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
8450 switch (TREE_CODE (t))
8452 case STATEMENT_LIST:
8454 tree_stmt_iterator i;
8455 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
8456 RECUR (tsi_stmt (i));
8460 case CTOR_INITIALIZER:
8461 finish_mem_initializers (tsubst_initializer_list
8462 (TREE_OPERAND (t, 0), args));
8466 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
8470 tmp = RECUR (EXPR_STMT_EXPR (t));
8471 if (EXPR_STMT_STMT_EXPR_RESULT (t))
8472 finish_stmt_expr_expr (tmp, cur_stmt_expr);
8474 finish_expr_stmt (tmp);
8478 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
8486 decl = DECL_EXPR_DECL (t);
8487 if (TREE_CODE (decl) == LABEL_DECL)
8488 finish_label_decl (DECL_NAME (decl));
8489 else if (TREE_CODE (decl) == USING_DECL)
8491 tree scope = USING_DECL_SCOPE (decl);
8492 tree name = DECL_NAME (decl);
8495 scope = RECUR (scope);
8496 decl = lookup_qualified_name (scope, name,
8497 /*is_type_p=*/false,
8498 /*complain=*/false);
8499 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
8500 qualified_name_lookup_error (scope, name, decl);
8502 do_local_using_decl (decl, scope, name);
8506 init = DECL_INITIAL (decl);
8507 decl = tsubst (decl, args, complain, in_decl);
8508 if (decl != error_mark_node)
8510 /* By marking the declaration as instantiated, we avoid
8511 trying to instantiate it. Since instantiate_decl can't
8512 handle local variables, and since we've already done
8513 all that needs to be done, that's the right thing to
8515 if (TREE_CODE (decl) == VAR_DECL)
8516 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8517 if (TREE_CODE (decl) == VAR_DECL
8518 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
8519 /* Anonymous aggregates are a special case. */
8520 finish_anon_union (decl);
8523 maybe_push_decl (decl);
8524 if (TREE_CODE (decl) == VAR_DECL
8525 && DECL_PRETTY_FUNCTION_P (decl))
8527 /* For __PRETTY_FUNCTION__ we have to adjust the
8529 const char *const name
8530 = cxx_printable_name (current_function_decl, 2);
8531 init = cp_fname_init (name, &TREE_TYPE (decl));
8534 init = RECUR (init);
8535 finish_decl (decl, init, NULL_TREE);
8540 /* A DECL_EXPR can also be used as an expression, in the condition
8541 clause of an if/for/while construct. */
8546 stmt = begin_for_stmt ();
8547 RECUR (FOR_INIT_STMT (t));
8548 finish_for_init_stmt (stmt);
8549 tmp = RECUR (FOR_COND (t));
8550 finish_for_cond (tmp, stmt);
8551 tmp = RECUR (FOR_EXPR (t));
8552 finish_for_expr (tmp, stmt);
8553 RECUR (FOR_BODY (t));
8554 finish_for_stmt (stmt);
8558 stmt = begin_while_stmt ();
8559 tmp = RECUR (WHILE_COND (t));
8560 finish_while_stmt_cond (tmp, stmt);
8561 RECUR (WHILE_BODY (t));
8562 finish_while_stmt (stmt);
8566 stmt = begin_do_stmt ();
8567 RECUR (DO_BODY (t));
8568 finish_do_body (stmt);
8569 tmp = RECUR (DO_COND (t));
8570 finish_do_stmt (tmp, stmt);
8574 stmt = begin_if_stmt ();
8575 tmp = RECUR (IF_COND (t));
8576 finish_if_stmt_cond (tmp, stmt);
8577 RECUR (THEN_CLAUSE (t));
8578 finish_then_clause (stmt);
8580 if (ELSE_CLAUSE (t))
8582 begin_else_clause (stmt);
8583 RECUR (ELSE_CLAUSE (t));
8584 finish_else_clause (stmt);
8587 finish_if_stmt (stmt);
8591 if (BIND_EXPR_BODY_BLOCK (t))
8592 stmt = begin_function_body ();
8594 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
8595 ? BCS_TRY_BLOCK : 0);
8597 RECUR (BIND_EXPR_BODY (t));
8599 if (BIND_EXPR_BODY_BLOCK (t))
8600 finish_function_body (stmt);
8602 finish_compound_stmt (stmt);
8606 finish_break_stmt ();
8610 finish_continue_stmt ();
8614 stmt = begin_switch_stmt ();
8615 tmp = RECUR (SWITCH_STMT_COND (t));
8616 finish_switch_cond (tmp, stmt);
8617 RECUR (SWITCH_STMT_BODY (t));
8618 finish_switch_stmt (stmt);
8621 case CASE_LABEL_EXPR:
8622 finish_case_label (RECUR (CASE_LOW (t)),
8623 RECUR (CASE_HIGH (t)));
8627 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
8631 tmp = GOTO_DESTINATION (t);
8632 if (TREE_CODE (tmp) != LABEL_DECL)
8633 /* Computed goto's must be tsubst'd into. On the other hand,
8634 non-computed gotos must not be; the identifier in question
8635 will have no binding. */
8638 tmp = DECL_NAME (tmp);
8639 finish_goto_stmt (tmp);
8643 tmp = finish_asm_stmt
8644 (ASM_VOLATILE_P (t),
8645 RECUR (ASM_STRING (t)),
8646 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
8647 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
8648 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
8650 tree asm_expr = tmp;
8651 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
8652 asm_expr = TREE_OPERAND (asm_expr, 0);
8653 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
8660 stmt = begin_try_block ();
8661 RECUR (TRY_STMTS (t));
8662 finish_cleanup_try_block (stmt);
8663 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
8667 tree compound_stmt = NULL_TREE;
8669 if (FN_TRY_BLOCK_P (t))
8670 stmt = begin_function_try_block (&compound_stmt);
8672 stmt = begin_try_block ();
8674 RECUR (TRY_STMTS (t));
8676 if (FN_TRY_BLOCK_P (t))
8677 finish_function_try_block (stmt);
8679 finish_try_block (stmt);
8681 RECUR (TRY_HANDLERS (t));
8682 if (FN_TRY_BLOCK_P (t))
8683 finish_function_handler_sequence (stmt, compound_stmt);
8685 finish_handler_sequence (stmt);
8691 tree decl = HANDLER_PARMS (t);
8695 decl = tsubst (decl, args, complain, in_decl);
8696 /* Prevent instantiate_decl from trying to instantiate
8697 this variable. We've already done all that needs to be
8699 if (decl != error_mark_node)
8700 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8702 stmt = begin_handler ();
8703 finish_handler_parms (decl, stmt);
8704 RECUR (HANDLER_BODY (t));
8705 finish_handler (stmt);
8710 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8716 tsubst_expr (STATIC_ASSERT_CONDITION (t),
8719 /*integral_constant_expression_p=*/true);
8720 finish_static_assert (condition,
8721 STATIC_ASSERT_MESSAGE (t),
8722 STATIC_ASSERT_SOURCE_LOCATION (t),
8723 /*member_p=*/false);
8728 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
8729 args, complain, in_decl);
8730 stmt = begin_omp_parallel ();
8731 RECUR (OMP_PARALLEL_BODY (t));
8732 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
8733 = OMP_PARALLEL_COMBINED (t);
8738 tree clauses, decl, init, cond, incr, body, pre_body;
8740 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
8741 args, complain, in_decl);
8742 init = OMP_FOR_INIT (t);
8743 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
8744 decl = RECUR (TREE_OPERAND (init, 0));
8745 init = RECUR (TREE_OPERAND (init, 1));
8746 cond = RECUR (OMP_FOR_COND (t));
8747 incr = RECUR (OMP_FOR_INCR (t));
8749 stmt = begin_omp_structured_block ();
8751 pre_body = push_stmt_list ();
8752 RECUR (OMP_FOR_PRE_BODY (t));
8753 pre_body = pop_stmt_list (pre_body);
8755 body = push_stmt_list ();
8756 RECUR (OMP_FOR_BODY (t));
8757 body = pop_stmt_list (body);
8759 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
8762 OMP_FOR_CLAUSES (t) = clauses;
8764 add_stmt (finish_omp_structured_block (stmt));
8770 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
8771 stmt = push_stmt_list ();
8772 RECUR (OMP_BODY (t));
8773 stmt = pop_stmt_list (stmt);
8776 OMP_BODY (t) = stmt;
8777 OMP_CLAUSES (t) = tmp;
8785 stmt = push_stmt_list ();
8786 RECUR (OMP_BODY (t));
8787 stmt = pop_stmt_list (stmt);
8790 OMP_BODY (t) = stmt;
8795 if (OMP_ATOMIC_DEPENDENT_P (t))
8797 tree op1 = TREE_OPERAND (t, 1);
8798 tree lhs = RECUR (TREE_OPERAND (op1, 0));
8799 tree rhs = RECUR (TREE_OPERAND (op1, 1));
8800 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
8805 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
8807 return tsubst_copy_and_build (t, args, complain, in_decl,
8808 /*function_p=*/false,
8809 integral_constant_expression_p);
8816 /* T is a postfix-expression that is not being used in a function
8817 call. Return the substituted version of T. */
8820 tsubst_non_call_postfix_expression (tree t, tree args,
8821 tsubst_flags_t complain,
8824 if (TREE_CODE (t) == SCOPE_REF)
8825 t = tsubst_qualified_id (t, args, complain, in_decl,
8826 /*done=*/false, /*address_p=*/false);
8828 t = tsubst_copy_and_build (t, args, complain, in_decl,
8829 /*function_p=*/false,
8830 /*integral_constant_expression_p=*/false);
8835 /* Like tsubst but deals with expressions and performs semantic
8836 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8839 tsubst_copy_and_build (tree t,
8841 tsubst_flags_t complain,
8844 bool integral_constant_expression_p)
8846 #define RECUR(NODE) \
8847 tsubst_copy_and_build (NODE, args, complain, in_decl, \
8848 /*function_p=*/false, \
8849 integral_constant_expression_p)
8853 if (t == NULL_TREE || t == error_mark_node)
8856 switch (TREE_CODE (t))
8861 case IDENTIFIER_NODE:
8865 bool non_integral_constant_expression_p;
8866 const char *error_msg;
8868 if (IDENTIFIER_TYPENAME_P (t))
8870 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8871 t = mangle_conv_op_name_for_type (new_type);
8874 /* Look up the name. */
8875 decl = lookup_name (t);
8877 /* By convention, expressions use ERROR_MARK_NODE to indicate
8878 failure, not NULL_TREE. */
8879 if (decl == NULL_TREE)
8880 decl = error_mark_node;
8882 decl = finish_id_expression (t, decl, NULL_TREE,
8884 integral_constant_expression_p,
8885 /*allow_non_integral_constant_expression_p=*/false,
8886 &non_integral_constant_expression_p,
8887 /*template_p=*/false,
8889 /*address_p=*/false,
8890 /*template_arg_p=*/false,
8894 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8895 decl = unqualified_name_lookup_error (decl);
8899 case TEMPLATE_ID_EXPR:
8902 tree template = RECUR (TREE_OPERAND (t, 0));
8903 tree targs = TREE_OPERAND (t, 1);
8906 targs = tsubst_template_args (targs, args, complain, in_decl);
8908 if (TREE_CODE (template) == COMPONENT_REF)
8910 object = TREE_OPERAND (template, 0);
8911 template = TREE_OPERAND (template, 1);
8915 template = lookup_template_function (template, targs);
8918 return build3 (COMPONENT_REF, TREE_TYPE (template),
8919 object, template, NULL_TREE);
8921 return baselink_for_fns (template);
8926 tree r = RECUR (TREE_OPERAND (t, 0));
8928 if (REFERENCE_REF_P (t))
8930 /* A type conversion to reference type will be enclosed in
8931 such an indirect ref, but the substitution of the cast
8932 will have also added such an indirect ref. */
8933 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
8934 r = convert_from_reference (r);
8937 r = build_x_indirect_ref (r, "unary *");
8943 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8944 RECUR (TREE_OPERAND (t, 0)));
8947 case REINTERPRET_CAST_EXPR:
8948 case CONST_CAST_EXPR:
8949 case DYNAMIC_CAST_EXPR:
8950 case STATIC_CAST_EXPR:
8955 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8956 if (integral_constant_expression_p
8957 && !cast_valid_in_integral_constant_expression_p (type))
8959 error ("a cast to a type other than an integral or "
8960 "enumeration type cannot appear in a constant-expression");
8961 return error_mark_node;
8964 op = RECUR (TREE_OPERAND (t, 0));
8966 switch (TREE_CODE (t))
8969 return build_functional_cast (type, op);
8970 case REINTERPRET_CAST_EXPR:
8971 return build_reinterpret_cast (type, op);
8972 case CONST_CAST_EXPR:
8973 return build_const_cast (type, op);
8974 case DYNAMIC_CAST_EXPR:
8975 return build_dynamic_cast (type, op);
8976 case STATIC_CAST_EXPR:
8977 return build_static_cast (type, op);
8983 case POSTDECREMENT_EXPR:
8984 case POSTINCREMENT_EXPR:
8985 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8986 args, complain, in_decl);
8987 return build_x_unary_op (TREE_CODE (t), op1);
8989 case PREDECREMENT_EXPR:
8990 case PREINCREMENT_EXPR:
8994 case TRUTH_NOT_EXPR:
8995 case UNARY_PLUS_EXPR: /* Unary + */
8998 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
9001 op1 = TREE_OPERAND (t, 0);
9002 if (TREE_CODE (op1) == SCOPE_REF)
9003 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
9004 /*done=*/true, /*address_p=*/true);
9006 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
9008 if (TREE_CODE (op1) == LABEL_DECL)
9009 return finish_label_address_expr (DECL_NAME (op1));
9010 return build_x_unary_op (ADDR_EXPR, op1);
9015 case TRUNC_DIV_EXPR:
9017 case FLOOR_DIV_EXPR:
9018 case ROUND_DIV_EXPR:
9019 case EXACT_DIV_EXPR:
9023 case TRUNC_MOD_EXPR:
9024 case FLOOR_MOD_EXPR:
9025 case TRUTH_ANDIF_EXPR:
9026 case TRUTH_ORIF_EXPR:
9027 case TRUTH_AND_EXPR:
9043 return build_x_binary_op
9045 RECUR (TREE_OPERAND (t, 0)),
9046 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
9048 : TREE_CODE (TREE_OPERAND (t, 0))),
9049 RECUR (TREE_OPERAND (t, 1)),
9050 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
9052 : TREE_CODE (TREE_OPERAND (t, 1))),
9053 /*overloaded_p=*/NULL);
9056 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
9057 /*address_p=*/false);
9059 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9060 args, complain, in_decl);
9061 return build_x_binary_op (ARRAY_REF, op1,
9062 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
9064 : TREE_CODE (TREE_OPERAND (t, 0))),
9065 RECUR (TREE_OPERAND (t, 1)),
9066 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
9068 : TREE_CODE (TREE_OPERAND (t, 1))),
9069 /*overloaded_p=*/NULL);
9073 op1 = TREE_OPERAND (t, 0);
9076 /* When there are no ARGS, we are trying to evaluate a
9077 non-dependent expression from the parser. Trying to do
9078 the substitutions may not work. */
9080 op1 = TREE_TYPE (op1);
9085 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
9086 /*function_p=*/false,
9087 /*integral_constant_expression_p=*/false);
9091 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
9093 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
9097 tree r = build_x_modify_expr
9098 (RECUR (TREE_OPERAND (t, 0)),
9099 TREE_CODE (TREE_OPERAND (t, 1)),
9100 RECUR (TREE_OPERAND (t, 2)));
9101 /* TREE_NO_WARNING must be set if either the expression was
9102 parenthesized or it uses an operator such as >>= rather
9103 than plain assignment. In the former case, it was already
9104 set and must be copied. In the latter case,
9105 build_x_modify_expr sets it and it must not be reset
9107 if (TREE_NO_WARNING (t))
9108 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9113 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9114 args, complain, in_decl);
9115 /* Remember that there was a reference to this entity. */
9118 return build_x_arrow (op1);
9122 (RECUR (TREE_OPERAND (t, 0)),
9123 RECUR (TREE_OPERAND (t, 1)),
9124 RECUR (TREE_OPERAND (t, 2)),
9125 RECUR (TREE_OPERAND (t, 3)),
9126 NEW_EXPR_USE_GLOBAL (t));
9129 return delete_sanity
9130 (RECUR (TREE_OPERAND (t, 0)),
9131 RECUR (TREE_OPERAND (t, 1)),
9132 DELETE_EXPR_USE_VEC (t),
9133 DELETE_EXPR_USE_GLOBAL (t));
9136 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
9137 RECUR (TREE_OPERAND (t, 1)));
9146 function = CALL_EXPR_FN (t);
9147 /* When we parsed the expression, we determined whether or
9148 not Koenig lookup should be performed. */
9149 koenig_p = KOENIG_LOOKUP_P (t);
9150 if (TREE_CODE (function) == SCOPE_REF)
9153 function = tsubst_qualified_id (function, args, complain, in_decl,
9155 /*address_p=*/false);
9159 if (TREE_CODE (function) == COMPONENT_REF)
9161 tree op = TREE_OPERAND (function, 1);
9163 qualified_p = (TREE_CODE (op) == SCOPE_REF
9165 && BASELINK_QUALIFIED_P (op)));
9168 qualified_p = false;
9170 function = tsubst_copy_and_build (function, args, complain,
9173 integral_constant_expression_p);
9175 if (BASELINK_P (function))
9179 /* FIXME: Rewrite this so as not to construct an arglist. */
9180 call_args = RECUR (CALL_EXPR_ARGS (t));
9182 /* We do not perform argument-dependent lookup if normal
9183 lookup finds a non-function, in accordance with the
9184 expected resolution of DR 218. */
9186 && ((is_overloaded_fn (function)
9187 /* If lookup found a member function, the Koenig lookup is
9188 not appropriate, even if an unqualified-name was used
9189 to denote the function. */
9190 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
9191 || TREE_CODE (function) == IDENTIFIER_NODE))
9192 function = perform_koenig_lookup (function, call_args);
9194 if (TREE_CODE (function) == IDENTIFIER_NODE)
9196 unqualified_name_lookup_error (function);
9197 return error_mark_node;
9200 /* Remember that there was a reference to this entity. */
9201 if (DECL_P (function))
9202 mark_used (function);
9204 if (TREE_CODE (function) == OFFSET_REF)
9205 return build_offset_ref_call_from_tree (function, call_args);
9206 if (TREE_CODE (function) == COMPONENT_REF)
9208 if (!BASELINK_P (TREE_OPERAND (function, 1)))
9209 return finish_call_expr (function, call_args,
9210 /*disallow_virtual=*/false,
9211 /*koenig_p=*/false);
9213 return (build_new_method_call
9214 (TREE_OPERAND (function, 0),
9215 TREE_OPERAND (function, 1),
9216 call_args, NULL_TREE,
9217 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
9220 return finish_call_expr (function, call_args,
9221 /*disallow_virtual=*/qualified_p,
9226 return build_x_conditional_expr
9227 (RECUR (TREE_OPERAND (t, 0)),
9228 RECUR (TREE_OPERAND (t, 1)),
9229 RECUR (TREE_OPERAND (t, 2)));
9231 case PSEUDO_DTOR_EXPR:
9232 return finish_pseudo_destructor_expr
9233 (RECUR (TREE_OPERAND (t, 0)),
9234 RECUR (TREE_OPERAND (t, 1)),
9235 RECUR (TREE_OPERAND (t, 2)));
9239 tree purpose, value, chain;
9241 if (t == void_list_node)
9244 purpose = TREE_PURPOSE (t);
9246 purpose = RECUR (purpose);
9247 value = TREE_VALUE (t);
9249 value = RECUR (value);
9250 chain = TREE_CHAIN (t);
9251 if (chain && chain != void_type_node)
9252 chain = RECUR (chain);
9253 if (purpose == TREE_PURPOSE (t)
9254 && value == TREE_VALUE (t)
9255 && chain == TREE_CHAIN (t))
9257 return tree_cons (purpose, value, chain);
9266 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
9267 args, complain, in_decl);
9268 /* Remember that there was a reference to this entity. */
9269 if (DECL_P (object))
9271 object_type = TREE_TYPE (object);
9273 member = TREE_OPERAND (t, 1);
9274 if (BASELINK_P (member))
9275 member = tsubst_baselink (member,
9276 non_reference (TREE_TYPE (object)),
9277 args, complain, in_decl);
9279 member = tsubst_copy (member, args, complain, in_decl);
9280 if (member == error_mark_node)
9281 return error_mark_node;
9283 if (object_type && !CLASS_TYPE_P (object_type))
9285 if (TREE_CODE (member) == BIT_NOT_EXPR)
9286 return finish_pseudo_destructor_expr (object,
9289 else if (TREE_CODE (member) == SCOPE_REF
9290 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
9291 return finish_pseudo_destructor_expr (object,
9295 else if (TREE_CODE (member) == SCOPE_REF
9296 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
9301 /* Lookup the template functions now that we know what the
9303 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
9304 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
9305 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
9306 /*is_type_p=*/false,
9307 /*complain=*/false);
9308 if (BASELINK_P (member))
9310 BASELINK_FUNCTIONS (member)
9311 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
9313 member = (adjust_result_of_qualified_name_lookup
9314 (member, BINFO_TYPE (BASELINK_BINFO (member)),
9319 qualified_name_lookup_error (object_type, tmpl, member);
9320 return error_mark_node;
9323 else if (TREE_CODE (member) == SCOPE_REF
9324 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
9325 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
9327 if (complain & tf_error)
9329 if (TYPE_P (TREE_OPERAND (member, 0)))
9330 error ("%qT is not a class or namespace",
9331 TREE_OPERAND (member, 0));
9333 error ("%qD is not a class or namespace",
9334 TREE_OPERAND (member, 0));
9336 return error_mark_node;
9338 else if (TREE_CODE (member) == FIELD_DECL)
9339 return finish_non_static_data_member (member, object, NULL_TREE);
9341 return finish_class_member_access_expr (object, member,
9342 /*template_p=*/false);
9347 (RECUR (TREE_OPERAND (t, 0)));
9351 VEC(constructor_elt,gc) *n;
9352 constructor_elt *ce;
9353 unsigned HOST_WIDE_INT idx;
9354 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9355 bool process_index_p;
9357 if (type == error_mark_node)
9358 return error_mark_node;
9360 /* digest_init will do the wrong thing if we let it. */
9361 if (type && TYPE_PTRMEMFUNC_P (type))
9364 /* We do not want to process the index of aggregate
9365 initializers as they are identifier nodes which will be
9366 looked up by digest_init. */
9367 process_index_p = !(type && IS_AGGR_TYPE (type));
9369 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
9370 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
9372 if (ce->index && process_index_p)
9373 ce->index = RECUR (ce->index);
9374 ce->value = RECUR (ce->value);
9377 if (TREE_HAS_CONSTRUCTOR (t))
9378 return finish_compound_literal (type, n);
9380 return build_constructor (NULL_TREE, n);
9385 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
9386 if (TYPE_P (operand_0))
9387 return get_typeid (operand_0);
9388 return build_typeid (operand_0);
9398 tree r = tsubst_copy (t, args, complain, in_decl);
9400 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
9401 /* If the original type was a reference, we'll be wrapped in
9402 the appropriate INDIRECT_REF. */
9403 r = convert_from_reference (r);
9408 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
9409 tsubst_copy (TREE_TYPE (t), args, complain,
9413 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
9417 tree old_stmt_expr = cur_stmt_expr;
9418 tree stmt_expr = begin_stmt_expr ();
9420 cur_stmt_expr = stmt_expr;
9421 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
9422 integral_constant_expression_p);
9423 stmt_expr = finish_stmt_expr (stmt_expr, false);
9424 cur_stmt_expr = old_stmt_expr;
9430 t = tsubst_copy (t, args, complain, in_decl);
9431 /* As in finish_id_expression, we resolve enumeration constants
9432 to their underlying values. */
9433 if (TREE_CODE (t) == CONST_DECL)
9435 used_types_insert (TREE_TYPE (t));
9436 return DECL_INITIAL (t);
9441 /* Handle Objective-C++ constructs, if appropriate. */
9444 = objcp_tsubst_copy_and_build (t, args, complain,
9445 in_decl, /*function_p=*/false);
9449 return tsubst_copy (t, args, complain, in_decl);
9455 /* Verify that the instantiated ARGS are valid. For type arguments,
9456 make sure that the type's linkage is ok. For non-type arguments,
9457 make sure they are constants if they are integral or enumerations.
9458 Emit an error under control of COMPLAIN, and return TRUE on error. */
9461 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
9463 int ix, len = DECL_NTPARMS (tmpl);
9464 bool result = false;
9466 for (ix = 0; ix != len; ix++)
9468 tree t = TREE_VEC_ELT (args, ix);
9472 /* [basic.link]: A name with no linkage (notably, the name
9473 of a class or enumeration declared in a local scope)
9474 shall not be used to declare an entity with linkage.
9475 This implies that names with no linkage cannot be used as
9476 template arguments. */
9477 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
9481 /* DR 488 makes use of a type with no linkage cause
9482 type deduction to fail. */
9483 if (complain & tf_error)
9485 if (TYPE_ANONYMOUS_P (nt))
9486 error ("%qT is/uses anonymous type", t);
9488 error ("template argument for %qD uses local type %qT",
9493 /* In order to avoid all sorts of complications, we do not
9494 allow variably-modified types as template arguments. */
9495 else if (variably_modified_type_p (t, NULL_TREE))
9497 if (complain & tf_error)
9498 error ("%qT is a variably modified type", t);
9502 /* A non-type argument of integral or enumerated type must be a
9504 else if (TREE_TYPE (t)
9505 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
9506 && !TREE_CONSTANT (t))
9508 if (complain & tf_error)
9509 error ("integral expression %qE is not constant", t);
9513 if (result && (complain & tf_error))
9514 error (" trying to instantiate %qD", tmpl);
9518 /* Instantiate the indicated variable or function template TMPL with
9519 the template arguments in TARG_PTR. */
9522 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
9527 HOST_WIDE_INT saved_processing_template_decl;
9529 if (tmpl == error_mark_node)
9530 return error_mark_node;
9532 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
9534 /* If this function is a clone, handle it specially. */
9535 if (DECL_CLONED_FUNCTION_P (tmpl))
9540 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
9542 if (spec == error_mark_node)
9543 return error_mark_node;
9545 /* Look for the clone. */
9546 FOR_EACH_CLONE (clone, spec)
9547 if (DECL_NAME (clone) == DECL_NAME (tmpl))
9549 /* We should always have found the clone by now. */
9554 /* Check to see if we already have this specialization. */
9555 spec = retrieve_specialization (tmpl, targ_ptr,
9556 /*class_specializations_p=*/false);
9557 if (spec != NULL_TREE)
9560 gen_tmpl = most_general_template (tmpl);
9561 if (tmpl != gen_tmpl)
9563 /* The TMPL is a partial instantiation. To get a full set of
9564 arguments we must add the arguments used to perform the
9565 partial instantiation. */
9566 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
9569 /* Check to see if we already have this specialization. */
9570 spec = retrieve_specialization (gen_tmpl, targ_ptr,
9571 /*class_specializations_p=*/false);
9572 if (spec != NULL_TREE)
9576 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
9578 return error_mark_node;
9580 /* We are building a FUNCTION_DECL, during which the access of its
9581 parameters and return types have to be checked. However this
9582 FUNCTION_DECL which is the desired context for access checking
9583 is not built yet. We solve this chicken-and-egg problem by
9584 deferring all checks until we have the FUNCTION_DECL. */
9585 push_deferring_access_checks (dk_deferred);
9587 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
9588 (because, for example, we have encountered a non-dependent
9589 function call in the body of a template function and must now
9590 determine which of several overloaded functions will be called),
9591 within the instantiation itself we are not processing a
9593 saved_processing_template_decl = processing_template_decl;
9594 processing_template_decl = 0;
9595 /* Substitute template parameters to obtain the specialization. */
9596 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
9597 targ_ptr, complain, gen_tmpl);
9598 processing_template_decl = saved_processing_template_decl;
9599 if (fndecl == error_mark_node)
9600 return error_mark_node;
9602 /* Now we know the specialization, compute access previously
9604 push_access_scope (fndecl);
9605 perform_deferred_access_checks ();
9606 pop_access_scope (fndecl);
9607 pop_deferring_access_checks ();
9609 /* The DECL_TI_TEMPLATE should always be the immediate parent
9610 template, not the most general template. */
9611 DECL_TI_TEMPLATE (fndecl) = tmpl;
9613 /* If we've just instantiated the main entry point for a function,
9614 instantiate all the alternate entry points as well. We do this
9615 by cloning the instantiation of the main entry point, not by
9616 instantiating the template clones. */
9617 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
9618 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
9623 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
9624 arguments that are being used when calling it. TARGS is a vector
9625 into which the deduced template arguments are placed.
9627 Return zero for success, 2 for an incomplete match that doesn't resolve
9628 all the types, and 1 for complete failure. An error message will be
9629 printed only for an incomplete match.
9631 If FN is a conversion operator, or we are trying to produce a specific
9632 specialization, RETURN_TYPE is the return type desired.
9634 The EXPLICIT_TARGS are explicit template arguments provided via a
9637 The parameter STRICT is one of:
9640 We are deducing arguments for a function call, as in
9644 We are deducing arguments for a conversion function, as in
9648 We are deducing arguments when doing an explicit instantiation
9649 as in [temp.explicit], when determining an explicit specialization
9650 as in [temp.expl.spec], or when taking the address of a function
9651 template, as in [temp.deduct.funcaddr]. */
9654 fn_type_unification (tree fn,
9655 tree explicit_targs,
9659 unification_kind_t strict,
9666 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
9668 fntype = TREE_TYPE (fn);
9673 The specified template arguments must match the template
9674 parameters in kind (i.e., type, nontype, template), and there
9675 must not be more arguments than there are parameters;
9676 otherwise type deduction fails.
9678 Nontype arguments must match the types of the corresponding
9679 nontype template parameters, or must be convertible to the
9680 types of the corresponding nontype parameters as specified in
9681 _temp.arg.nontype_, otherwise type deduction fails.
9683 All references in the function type of the function template
9684 to the corresponding template parameters are replaced by the
9685 specified template argument values. If a substitution in a
9686 template parameter or in the function type of the function
9687 template results in an invalid type, type deduction fails. */
9689 tree converted_args;
9692 if (explicit_targs == error_mark_node)
9696 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9697 explicit_targs, NULL_TREE, tf_none,
9698 /*require_all_args=*/false,
9699 /*use_default_args=*/false));
9700 if (converted_args == error_mark_node)
9703 /* Substitute the explicit args into the function type. This is
9704 necessary so that, for instance, explicitly declared function
9705 arguments can match null pointed constants. If we were given
9706 an incomplete set of explicit args, we must not do semantic
9707 processing during substitution as we could create partial
9709 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
9710 processing_template_decl += incomplete;
9711 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
9712 processing_template_decl -= incomplete;
9714 if (fntype == error_mark_node)
9717 /* Place the explicitly specified arguments in TARGS. */
9718 for (i = NUM_TMPL_ARGS (converted_args); i--;)
9719 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
9722 /* Never do unification on the 'this' parameter. */
9723 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
9727 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
9728 args = tree_cons (NULL_TREE, return_type, args);
9731 /* We allow incomplete unification without an error message here
9732 because the standard doesn't seem to explicitly prohibit it. Our
9733 callers must be ready to deal with unification failures in any
9735 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9736 targs, parms, args, /*subr=*/0,
9740 /* All is well so far. Now, check:
9744 When all template arguments have been deduced, all uses of
9745 template parameters in nondeduced contexts are replaced with
9746 the corresponding deduced argument values. If the
9747 substitution results in an invalid type, as described above,
9748 type deduction fails. */
9749 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
9756 /* Adjust types before performing type deduction, as described in
9757 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
9758 sections are symmetric. PARM is the type of a function parameter
9759 or the return type of the conversion function. ARG is the type of
9760 the argument passed to the call, or the type of the value
9761 initialized with the result of the conversion function. */
9764 maybe_adjust_types_for_deduction (unification_kind_t strict,
9777 /* Swap PARM and ARG throughout the remainder of this
9778 function; the handling is precisely symmetric since PARM
9779 will initialize ARG rather than vice versa. */
9787 /* There is nothing to do in this case. */
9794 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9796 /* [temp.deduct.call]
9798 If P is not a reference type:
9800 --If A is an array type, the pointer type produced by the
9801 array-to-pointer standard conversion (_conv.array_) is
9802 used in place of A for type deduction; otherwise,
9804 --If A is a function type, the pointer type produced by
9805 the function-to-pointer standard conversion
9806 (_conv.func_) is used in place of A for type deduction;
9809 --If A is a cv-qualified type, the top level
9810 cv-qualifiers of A's type are ignored for type
9812 if (TREE_CODE (*arg) == ARRAY_TYPE)
9813 *arg = build_pointer_type (TREE_TYPE (*arg));
9814 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9815 *arg = build_pointer_type (*arg);
9817 *arg = TYPE_MAIN_VARIANT (*arg);
9820 /* [temp.deduct.call]
9822 If P is a cv-qualified type, the top level cv-qualifiers
9823 of P's type are ignored for type deduction. If P is a
9824 reference type, the type referred to by P is used for
9826 *parm = TYPE_MAIN_VARIANT (*parm);
9827 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9829 *parm = TREE_TYPE (*parm);
9830 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9833 /* DR 322. For conversion deduction, remove a reference type on parm
9834 too (which has been swapped into ARG). */
9835 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9836 *arg = TREE_TYPE (*arg);
9841 /* Most parms like fn_type_unification.
9843 If SUBR is 1, we're being called recursively (to unify the
9844 arguments of a function or method parameter of a function
9848 type_unification_real (tree tparms,
9853 unification_kind_t strict,
9858 int ntparms = TREE_VEC_LENGTH (tparms);
9860 int saw_undeduced = 0;
9863 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
9864 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
9865 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
9866 gcc_assert (ntparms > 0);
9871 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9872 | UNIFY_ALLOW_DERIVED);
9876 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9880 sub_strict = UNIFY_ALLOW_NONE;
9891 while (parms && parms != void_list_node
9892 && args && args != void_list_node)
9894 parm = TREE_VALUE (parms);
9895 parms = TREE_CHAIN (parms);
9896 arg = TREE_VALUE (args);
9897 args = TREE_CHAIN (args);
9899 if (arg == error_mark_node)
9901 if (arg == unknown_type_node)
9902 /* We can't deduce anything from this, but we might get all the
9903 template args from other function args. */
9906 /* Conversions will be performed on a function argument that
9907 corresponds with a function parameter that contains only
9908 non-deducible template parameters and explicitly specified
9909 template parameters. */
9910 if (!uses_template_parms (parm))
9915 type = TREE_TYPE (arg);
9919 if (same_type_p (parm, type))
9921 if (strict != DEDUCE_EXACT
9922 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
9931 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
9932 if (type_unknown_p (arg))
9934 /* [temp.deduct.type] A template-argument can be deduced from
9935 a pointer to function or pointer to member function
9936 argument if the set of overloaded functions does not
9937 contain function templates and at most one of a set of
9938 overloaded functions provides a unique match. */
9940 if (resolve_overloaded_unification
9941 (tparms, targs, parm, arg, strict, sub_strict)
9946 arg = TREE_TYPE (arg);
9947 if (arg == error_mark_node)
9952 int arg_strict = sub_strict;
9955 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9957 if (unify (tparms, targs, parm, arg, arg_strict))
9962 /* Fail if we've reached the end of the parm list, and more args
9963 are present, and the parm list isn't variadic. */
9964 if (args && args != void_list_node && parms == void_list_node)
9966 /* Fail if parms are left and they don't have default values. */
9967 if (parms && parms != void_list_node
9968 && TREE_PURPOSE (parms) == NULL_TREE)
9972 for (i = 0; i < ntparms; i++)
9973 if (!TREE_VEC_ELT (targs, i))
9977 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
9980 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
9982 /* If this is an undeduced nontype parameter that depends on
9983 a type parameter, try another pass; its type may have been
9984 deduced from a later argument than the one from which
9985 this parameter can be deduced. */
9986 if (TREE_CODE (tparm) == PARM_DECL
9987 && uses_template_parms (TREE_TYPE (tparm))
9988 && !saw_undeduced++)
9997 /* Subroutine of type_unification_real. Args are like the variables at the
9998 call site. ARG is an overloaded function (or template-id); we try
9999 deducing template args from each of the overloads, and if only one
10000 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
10003 resolve_overloaded_unification (tree tparms,
10007 unification_kind_t strict,
10010 tree tempargs = copy_node (targs);
10014 if (TREE_CODE (arg) == ADDR_EXPR)
10016 arg = TREE_OPERAND (arg, 0);
10022 if (TREE_CODE (arg) == COMPONENT_REF)
10023 /* Handle `&x' where `x' is some static or non-static member
10025 arg = TREE_OPERAND (arg, 1);
10027 if (TREE_CODE (arg) == OFFSET_REF)
10028 arg = TREE_OPERAND (arg, 1);
10030 /* Strip baselink information. */
10031 if (BASELINK_P (arg))
10032 arg = BASELINK_FUNCTIONS (arg);
10034 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
10036 /* If we got some explicit template args, we need to plug them into
10037 the affected templates before we try to unify, in case the
10038 explicit args will completely resolve the templates in question. */
10040 tree expl_subargs = TREE_OPERAND (arg, 1);
10041 arg = TREE_OPERAND (arg, 0);
10043 for (; arg; arg = OVL_NEXT (arg))
10045 tree fn = OVL_CURRENT (arg);
10046 tree subargs, elem;
10048 if (TREE_CODE (fn) != TEMPLATE_DECL)
10051 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
10052 expl_subargs, /*check_ret=*/false);
10055 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
10056 good += try_one_overload (tparms, targs, tempargs, parm,
10057 elem, strict, sub_strict, addr_p);
10063 gcc_assert (TREE_CODE (arg) == OVERLOAD
10064 || TREE_CODE (arg) == FUNCTION_DECL);
10066 for (; arg; arg = OVL_NEXT (arg))
10067 good += try_one_overload (tparms, targs, tempargs, parm,
10068 TREE_TYPE (OVL_CURRENT (arg)),
10069 strict, sub_strict, addr_p);
10072 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10073 to function or pointer to member function argument if the set of
10074 overloaded functions does not contain function templates and at most
10075 one of a set of overloaded functions provides a unique match.
10077 So if we found multiple possibilities, we return success but don't
10078 deduce anything. */
10082 int i = TREE_VEC_LENGTH (targs);
10084 if (TREE_VEC_ELT (tempargs, i))
10085 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
10093 /* Subroutine of resolve_overloaded_unification; does deduction for a single
10094 overload. Fills TARGS with any deduced arguments, or error_mark_node if
10095 different overloads deduce different arguments for a given parm.
10096 ADDR_P is true if the expression for which deduction is being
10097 performed was of the form "& fn" rather than simply "fn".
10099 Returns 1 on success. */
10102 try_one_overload (tree tparms,
10107 unification_kind_t strict,
10115 /* [temp.deduct.type] A template-argument can be deduced from a pointer
10116 to function or pointer to member function argument if the set of
10117 overloaded functions does not contain function templates and at most
10118 one of a set of overloaded functions provides a unique match.
10120 So if this is a template, just return success. */
10122 if (uses_template_parms (arg))
10125 if (TREE_CODE (arg) == METHOD_TYPE)
10126 arg = build_ptrmemfunc_type (build_pointer_type (arg));
10128 arg = build_pointer_type (arg);
10130 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
10132 /* We don't copy orig_targs for this because if we have already deduced
10133 some template args from previous args, unify would complain when we
10134 try to deduce a template parameter for the same argument, even though
10135 there isn't really a conflict. */
10136 nargs = TREE_VEC_LENGTH (targs);
10137 tempargs = make_tree_vec (nargs);
10139 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
10142 /* First make sure we didn't deduce anything that conflicts with
10143 explicitly specified args. */
10144 for (i = nargs; i--; )
10146 tree elt = TREE_VEC_ELT (tempargs, i);
10147 tree oldelt = TREE_VEC_ELT (orig_targs, i);
10151 else if (uses_template_parms (elt))
10152 /* Since we're unifying against ourselves, we will fill in
10153 template args used in the function parm list with our own
10154 template parms. Discard them. */
10155 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
10156 else if (oldelt && !template_args_equal (oldelt, elt))
10160 for (i = nargs; i--; )
10162 tree elt = TREE_VEC_ELT (tempargs, i);
10165 TREE_VEC_ELT (targs, i) = elt;
10171 /* PARM is a template class (perhaps with unbound template
10172 parameters). ARG is a fully instantiated type. If ARG can be
10173 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
10174 TARGS are as for unify. */
10177 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
10179 tree copy_of_targs;
10181 if (!CLASSTYPE_TEMPLATE_INFO (arg)
10182 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
10183 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
10186 /* We need to make a new template argument vector for the call to
10187 unify. If we used TARGS, we'd clutter it up with the result of
10188 the attempted unification, even if this class didn't work out.
10189 We also don't want to commit ourselves to all the unifications
10190 we've already done, since unification is supposed to be done on
10191 an argument-by-argument basis. In other words, consider the
10192 following pathological case:
10194 template <int I, int J, int K>
10197 template <int I, int J>
10198 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
10200 template <int I, int J, int K>
10201 void f(S<I, J, K>, S<I, I, I>);
10210 Now, by the time we consider the unification involving `s2', we
10211 already know that we must have `f<0, 0, 0>'. But, even though
10212 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
10213 because there are two ways to unify base classes of S<0, 1, 2>
10214 with S<I, I, I>. If we kept the already deduced knowledge, we
10215 would reject the possibility I=1. */
10216 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
10218 /* If unification failed, we're done. */
10219 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
10220 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
10226 /* Given a template type PARM and a class type ARG, find the unique
10227 base type in ARG that is an instance of PARM. We do not examine
10228 ARG itself; only its base-classes. If there is not exactly one
10229 appropriate base class, return NULL_TREE. PARM may be the type of
10230 a partial specialization, as well as a plain template type. Used
10234 get_template_base (tree tparms, tree targs, tree parm, tree arg)
10236 tree rval = NULL_TREE;
10239 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
10241 binfo = TYPE_BINFO (complete_type (arg));
10243 /* The type could not be completed. */
10246 /* Walk in inheritance graph order. The search order is not
10247 important, and this avoids multiple walks of virtual bases. */
10248 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
10250 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
10254 /* If there is more than one satisfactory baseclass, then:
10258 If they yield more than one possible deduced A, the type
10262 if (rval && !same_type_p (r, rval))
10272 /* Returns the level of DECL, which declares a template parameter. */
10275 template_decl_level (tree decl)
10277 switch (TREE_CODE (decl))
10280 case TEMPLATE_DECL:
10281 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
10284 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
10287 gcc_unreachable ();
10292 /* Decide whether ARG can be unified with PARM, considering only the
10293 cv-qualifiers of each type, given STRICT as documented for unify.
10294 Returns nonzero iff the unification is OK on that basis. */
10297 check_cv_quals_for_unify (int strict, tree arg, tree parm)
10299 int arg_quals = cp_type_quals (arg);
10300 int parm_quals = cp_type_quals (parm);
10302 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10303 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10305 /* Although a CVR qualifier is ignored when being applied to a
10306 substituted template parameter ([8.3.2]/1 for example), that
10307 does not apply during deduction [14.8.2.4]/1, (even though
10308 that is not explicitly mentioned, [14.8.2.4]/9 indicates
10309 this). Except when we're allowing additional CV qualifiers
10310 at the outer level [14.8.2.1]/3,1st bullet. */
10311 if ((TREE_CODE (arg) == REFERENCE_TYPE
10312 || TREE_CODE (arg) == FUNCTION_TYPE
10313 || TREE_CODE (arg) == METHOD_TYPE)
10314 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
10317 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
10318 && (parm_quals & TYPE_QUAL_RESTRICT))
10322 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
10323 && (arg_quals & parm_quals) != parm_quals)
10326 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
10327 && (parm_quals & arg_quals) != arg_quals)
10333 /* Deduce the value of template parameters. TPARMS is the (innermost)
10334 set of template parameters to a template. TARGS is the bindings
10335 for those template parameters, as determined thus far; TARGS may
10336 include template arguments for outer levels of template parameters
10337 as well. PARM is a parameter to a template function, or a
10338 subcomponent of that parameter; ARG is the corresponding argument.
10339 This function attempts to match PARM with ARG in a manner
10340 consistent with the existing assignments in TARGS. If more values
10341 are deduced, then TARGS is updated.
10343 Returns 0 if the type deduction succeeds, 1 otherwise. The
10344 parameter STRICT is a bitwise or of the following flags:
10347 Require an exact match between PARM and ARG.
10348 UNIFY_ALLOW_MORE_CV_QUAL:
10349 Allow the deduced ARG to be more cv-qualified (by qualification
10350 conversion) than ARG.
10351 UNIFY_ALLOW_LESS_CV_QUAL:
10352 Allow the deduced ARG to be less cv-qualified than ARG.
10353 UNIFY_ALLOW_DERIVED:
10354 Allow the deduced ARG to be a template base class of ARG,
10355 or a pointer to a template base class of the type pointed to by
10357 UNIFY_ALLOW_INTEGER:
10358 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
10359 case for more information.
10360 UNIFY_ALLOW_OUTER_LEVEL:
10361 This is the outermost level of a deduction. Used to determine validity
10362 of qualification conversions. A valid qualification conversion must
10363 have const qualified pointers leading up to the inner type which
10364 requires additional CV quals, except at the outer level, where const
10365 is not required [conv.qual]. It would be normal to set this flag in
10366 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
10367 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
10368 This is the outermost level of a deduction, and PARM can be more CV
10369 qualified at this point.
10370 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
10371 This is the outermost level of a deduction, and PARM can be less CV
10372 qualified at this point. */
10375 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
10380 int strict_in = strict;
10382 /* I don't think this will do the right thing with respect to types.
10383 But the only case I've seen it in so far has been array bounds, where
10384 signedness is the only information lost, and I think that will be
10386 while (TREE_CODE (parm) == NOP_EXPR)
10387 parm = TREE_OPERAND (parm, 0);
10389 if (arg == error_mark_node)
10391 if (arg == unknown_type_node)
10392 /* We can't deduce anything from this, but we might get all the
10393 template args from other function args. */
10396 /* If PARM uses template parameters, then we can't bail out here,
10397 even if ARG == PARM, since we won't record unifications for the
10398 template parameters. We might need them if we're trying to
10399 figure out which of two things is more specialized. */
10400 if (arg == parm && !uses_template_parms (parm))
10403 /* Immediately reject some pairs that won't unify because of
10404 cv-qualification mismatches. */
10405 if (TREE_CODE (arg) == TREE_CODE (parm)
10407 /* It is the elements of the array which hold the cv quals of an array
10408 type, and the elements might be template type parms. We'll check
10409 when we recurse. */
10410 && TREE_CODE (arg) != ARRAY_TYPE
10411 /* We check the cv-qualifiers when unifying with template type
10412 parameters below. We want to allow ARG `const T' to unify with
10413 PARM `T' for example, when computing which of two templates
10414 is more specialized, for example. */
10415 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
10416 && !check_cv_quals_for_unify (strict_in, arg, parm))
10419 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
10420 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
10421 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
10422 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
10423 strict &= ~UNIFY_ALLOW_DERIVED;
10424 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
10425 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
10427 switch (TREE_CODE (parm))
10429 case TYPENAME_TYPE:
10431 case UNBOUND_CLASS_TEMPLATE:
10432 /* In a type which contains a nested-name-specifier, template
10433 argument values cannot be deduced for template parameters used
10434 within the nested-name-specifier. */
10437 case TEMPLATE_TYPE_PARM:
10438 case TEMPLATE_TEMPLATE_PARM:
10439 case BOUND_TEMPLATE_TEMPLATE_PARM:
10440 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10442 if (TEMPLATE_TYPE_LEVEL (parm)
10443 != template_decl_level (tparm))
10444 /* The PARM is not one we're trying to unify. Just check
10445 to see if it matches ARG. */
10446 return (TREE_CODE (arg) == TREE_CODE (parm)
10447 && same_type_p (parm, arg)) ? 0 : 1;
10448 idx = TEMPLATE_TYPE_IDX (parm);
10449 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10450 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
10452 /* Check for mixed types and values. */
10453 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
10454 && TREE_CODE (tparm) != TYPE_DECL)
10455 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10456 && TREE_CODE (tparm) != TEMPLATE_DECL))
10459 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10461 /* ARG must be constructed from a template class or a template
10462 template parameter. */
10463 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
10464 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
10468 tree parmvec = TYPE_TI_ARGS (parm);
10469 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
10471 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
10474 /* The resolution to DR150 makes clear that default
10475 arguments for an N-argument may not be used to bind T
10476 to a template template parameter with fewer than N
10477 parameters. It is not safe to permit the binding of
10478 default arguments as an extension, as that may change
10479 the meaning of a conforming program. Consider:
10481 struct Dense { static const unsigned int dim = 1; };
10483 template <template <typename> class View,
10485 void operator+(float, View<Block> const&);
10487 template <typename Block,
10488 unsigned int Dim = Block::dim>
10489 struct Lvalue_proxy { operator float() const; };
10493 Lvalue_proxy<Dense> p;
10498 Here, if Lvalue_proxy is permitted to bind to View, then
10499 the global operator+ will be used; if they are not, the
10500 Lvalue_proxy will be converted to float. */
10501 if (coerce_template_parms (argtmplvec, parmvec,
10502 TYPE_TI_TEMPLATE (parm),
10504 /*require_all_args=*/true,
10505 /*use_default_args=*/false)
10506 == error_mark_node)
10509 /* Deduce arguments T, i from TT<T> or TT<i>.
10510 We check each element of PARMVEC and ARGVEC individually
10511 rather than the whole TREE_VEC since they can have
10512 different number of elements. */
10514 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
10516 if (unify (tparms, targs,
10517 TREE_VEC_ELT (parmvec, i),
10518 TREE_VEC_ELT (argvec, i),
10523 arg = TYPE_TI_TEMPLATE (arg);
10525 /* Fall through to deduce template name. */
10528 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10529 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10531 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
10533 /* Simple cases: Value already set, does match or doesn't. */
10534 if (targ != NULL_TREE && template_args_equal (targ, arg))
10541 /* If PARM is `const T' and ARG is only `int', we don't have
10542 a match unless we are allowing additional qualification.
10543 If ARG is `const int' and PARM is just `T' that's OK;
10544 that binds `const int' to `T'. */
10545 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
10549 /* Consider the case where ARG is `const volatile int' and
10550 PARM is `const T'. Then, T should be `volatile int'. */
10551 arg = cp_build_qualified_type_real
10552 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
10553 if (arg == error_mark_node)
10556 /* Simple cases: Value already set, does match or doesn't. */
10557 if (targ != NULL_TREE && same_type_p (targ, arg))
10562 /* Make sure that ARG is not a variable-sized array. (Note
10563 that were talking about variable-sized arrays (like
10564 `int[n]'), rather than arrays of unknown size (like
10565 `int[]').) We'll get very confused by such a type since
10566 the bound of the array will not be computable in an
10567 instantiation. Besides, such types are not allowed in
10568 ISO C++, so we can do as we please here. */
10569 if (variably_modified_type_p (arg, NULL_TREE))
10573 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10576 case TEMPLATE_PARM_INDEX:
10577 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10578 if (tparm == error_mark_node)
10581 if (TEMPLATE_PARM_LEVEL (parm)
10582 != template_decl_level (tparm))
10583 /* The PARM is not one we're trying to unify. Just check
10584 to see if it matches ARG. */
10585 return !(TREE_CODE (arg) == TREE_CODE (parm)
10586 && cp_tree_equal (parm, arg));
10588 idx = TEMPLATE_PARM_IDX (parm);
10589 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
10592 return !cp_tree_equal (targ, arg);
10594 /* [temp.deduct.type] If, in the declaration of a function template
10595 with a non-type template-parameter, the non-type
10596 template-parameter is used in an expression in the function
10597 parameter-list and, if the corresponding template-argument is
10598 deduced, the template-argument type shall match the type of the
10599 template-parameter exactly, except that a template-argument
10600 deduced from an array bound may be of any integral type.
10601 The non-type parameter might use already deduced type parameters. */
10602 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
10603 if (!TREE_TYPE (arg))
10604 /* Template-parameter dependent expression. Just accept it for now.
10605 It will later be processed in convert_template_argument. */
10607 else if (same_type_p (TREE_TYPE (arg), tparm))
10609 else if ((strict & UNIFY_ALLOW_INTEGER)
10610 && (TREE_CODE (tparm) == INTEGER_TYPE
10611 || TREE_CODE (tparm) == BOOLEAN_TYPE))
10612 /* Convert the ARG to the type of PARM; the deduced non-type
10613 template argument must exactly match the types of the
10614 corresponding parameter. */
10615 arg = fold (build_nop (TREE_TYPE (parm), arg));
10616 else if (uses_template_parms (tparm))
10617 /* We haven't deduced the type of this parameter yet. Try again
10623 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
10628 /* A pointer-to-member constant can be unified only with
10629 another constant. */
10630 if (TREE_CODE (arg) != PTRMEM_CST)
10633 /* Just unify the class member. It would be useless (and possibly
10634 wrong, depending on the strict flags) to unify also
10635 PTRMEM_CST_CLASS, because we want to be sure that both parm and
10636 arg refer to the same variable, even if through different
10637 classes. For instance:
10639 struct A { int x; };
10642 Unification of &A::x and &B::x must succeed. */
10643 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
10644 PTRMEM_CST_MEMBER (arg), strict);
10649 if (TREE_CODE (arg) != POINTER_TYPE)
10652 /* [temp.deduct.call]
10654 A can be another pointer or pointer to member type that can
10655 be converted to the deduced A via a qualification
10656 conversion (_conv.qual_).
10658 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
10659 This will allow for additional cv-qualification of the
10660 pointed-to types if appropriate. */
10662 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10663 /* The derived-to-base conversion only persists through one
10664 level of pointers. */
10665 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10667 return unify (tparms, targs, TREE_TYPE (parm),
10668 TREE_TYPE (arg), strict);
10671 case REFERENCE_TYPE:
10672 if (TREE_CODE (arg) != REFERENCE_TYPE)
10674 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10675 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10678 if (TREE_CODE (arg) != ARRAY_TYPE)
10680 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10681 != (TYPE_DOMAIN (arg) == NULL_TREE))
10683 if (TYPE_DOMAIN (parm) != NULL_TREE)
10690 /* Our representation of array types uses "N - 1" as the
10691 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
10692 not an integer constant. We cannot unify arbitrarily
10693 complex expressions, so we eliminate the MINUS_EXPRs
10695 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
10696 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
10699 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
10700 parm_max = TREE_OPERAND (parm_max, 0);
10702 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
10703 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
10706 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
10707 trying to unify the type of a variable with the type
10708 of a template parameter. For example:
10710 template <unsigned int N>
10711 void f (char (&) [N]);
10718 Here, the type of the ARG will be "int [g(i)]", and
10719 may be a SAVE_EXPR, etc. */
10720 if (TREE_CODE (arg_max) != MINUS_EXPR)
10722 arg_max = TREE_OPERAND (arg_max, 0);
10725 /* If only one of the bounds used a MINUS_EXPR, compensate
10726 by adding one to the other bound. */
10727 if (parm_cst && !arg_cst)
10728 parm_max = fold_build2 (PLUS_EXPR,
10732 else if (arg_cst && !parm_cst)
10733 arg_max = fold_build2 (PLUS_EXPR,
10738 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
10741 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10742 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10749 case ENUMERAL_TYPE:
10751 if (TREE_CODE (arg) != TREE_CODE (parm))
10754 /* We have already checked cv-qualification at the top of the
10756 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10759 /* As far as unification is concerned, this wins. Later checks
10760 will invalidate it if necessary. */
10763 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10764 /* Type INTEGER_CST can come from ordinary constant template args. */
10766 while (TREE_CODE (arg) == NOP_EXPR)
10767 arg = TREE_OPERAND (arg, 0);
10769 if (TREE_CODE (arg) != INTEGER_CST)
10771 return !tree_int_cst_equal (parm, arg);
10776 if (TREE_CODE (arg) != TREE_VEC)
10778 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10780 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10781 if (unify (tparms, targs,
10782 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10790 if (TREE_CODE (arg) != TREE_CODE (parm))
10793 if (TYPE_PTRMEMFUNC_P (parm))
10795 if (!TYPE_PTRMEMFUNC_P (arg))
10798 return unify (tparms, targs,
10799 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10800 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10804 if (CLASSTYPE_TEMPLATE_INFO (parm))
10806 tree t = NULL_TREE;
10808 if (strict_in & UNIFY_ALLOW_DERIVED)
10810 /* First, we try to unify the PARM and ARG directly. */
10811 t = try_class_unification (tparms, targs,
10816 /* Fallback to the special case allowed in
10817 [temp.deduct.call]:
10819 If P is a class, and P has the form
10820 template-id, then A can be a derived class of
10821 the deduced A. Likewise, if P is a pointer to
10822 a class of the form template-id, A can be a
10823 pointer to a derived class pointed to by the
10825 t = get_template_base (tparms, targs, parm, arg);
10831 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10832 && (CLASSTYPE_TI_TEMPLATE (parm)
10833 == CLASSTYPE_TI_TEMPLATE (arg)))
10834 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10835 Then, we should unify `int' and `U'. */
10838 /* There's no chance of unification succeeding. */
10841 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10842 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10844 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10849 case FUNCTION_TYPE:
10850 if (TREE_CODE (arg) != TREE_CODE (parm))
10853 /* CV qualifications for methods can never be deduced, they must
10854 match exactly. We need to check them explicitly here,
10855 because type_unification_real treats them as any other
10856 cvqualified parameter. */
10857 if (TREE_CODE (parm) == METHOD_TYPE
10858 && (!check_cv_quals_for_unify
10860 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
10861 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
10864 if (unify (tparms, targs, TREE_TYPE (parm),
10865 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10867 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10868 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
10872 /* Unify a pointer to member with a pointer to member function, which
10873 deduces the type of the member as a function type. */
10874 if (TYPE_PTRMEMFUNC_P (arg))
10878 cp_cv_quals cv_quals;
10880 /* Check top-level cv qualifiers */
10881 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
10884 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10885 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
10888 /* Determine the type of the function we are unifying against. */
10889 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
10891 build_function_type (TREE_TYPE (method_type),
10892 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
10894 /* Extract the cv-qualifiers of the member function from the
10895 implicit object parameter and place them on the function
10896 type to be restored later. */
10898 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
10899 fntype = build_qualified_type (fntype, cv_quals);
10900 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
10903 if (TREE_CODE (arg) != OFFSET_TYPE)
10905 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10906 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10908 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10912 if (DECL_TEMPLATE_PARM_P (parm))
10913 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10914 if (arg != integral_constant_value (parm))
10919 case TEMPLATE_DECL:
10920 /* Matched cases are handled by the ARG == PARM test above. */
10924 gcc_assert (EXPR_P (parm));
10926 /* We must be looking at an expression. This can happen with
10930 void foo(S<I>, S<I + 2>);
10932 This is a "nondeduced context":
10936 The nondeduced contexts are:
10938 --A type that is a template-id in which one or more of
10939 the template-arguments is an expression that references
10940 a template-parameter.
10942 In these cases, we assume deduction succeeded, but don't
10943 actually infer any unifications. */
10945 if (!uses_template_parms (parm)
10946 && !template_args_equal (parm, arg))
10953 /* Note that DECL can be defined in this translation unit, if
10957 mark_definable (tree decl)
10960 DECL_NOT_REALLY_EXTERN (decl) = 1;
10961 FOR_EACH_CLONE (clone, decl)
10962 DECL_NOT_REALLY_EXTERN (clone) = 1;
10965 /* Called if RESULT is explicitly instantiated, or is a member of an
10966 explicitly instantiated class. */
10969 mark_decl_instantiated (tree result, int extern_p)
10971 SET_DECL_EXPLICIT_INSTANTIATION (result);
10973 /* If this entity has already been written out, it's too late to
10974 make any modifications. */
10975 if (TREE_ASM_WRITTEN (result))
10978 if (TREE_CODE (result) != FUNCTION_DECL)
10979 /* The TREE_PUBLIC flag for function declarations will have been
10980 set correctly by tsubst. */
10981 TREE_PUBLIC (result) = 1;
10983 /* This might have been set by an earlier implicit instantiation. */
10984 DECL_COMDAT (result) = 0;
10987 DECL_NOT_REALLY_EXTERN (result) = 0;
10990 mark_definable (result);
10991 /* Always make artificials weak. */
10992 if (DECL_ARTIFICIAL (result) && flag_weak)
10993 comdat_linkage (result);
10994 /* For WIN32 we also want to put explicit instantiations in
10995 linkonce sections. */
10996 else if (TREE_PUBLIC (result))
10997 maybe_make_one_only (result);
11000 /* If EXTERN_P, then this function will not be emitted -- unless
11001 followed by an explicit instantiation, at which point its linkage
11002 will be adjusted. If !EXTERN_P, then this function will be
11003 emitted here. In neither circumstance do we want
11004 import_export_decl to adjust the linkage. */
11005 DECL_INTERFACE_KNOWN (result) = 1;
11008 /* Given two function templates PAT1 and PAT2, return:
11010 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
11011 -1 if PAT2 is more specialized than PAT1.
11012 0 if neither is more specialized.
11014 LEN indicates the number of parameters we should consider
11015 (defaulted parameters should not be considered).
11017 The 1998 std underspecified function template partial ordering, and
11018 DR214 addresses the issue. We take pairs of arguments, one from
11019 each of the templates, and deduce them against each other. One of
11020 the templates will be more specialized if all the *other*
11021 template's arguments deduce against its arguments and at least one
11022 of its arguments *does* *not* deduce against the other template's
11023 corresponding argument. Deduction is done as for class templates.
11024 The arguments used in deduction have reference and top level cv
11025 qualifiers removed. Iff both arguments were originally reference
11026 types *and* deduction succeeds in both directions, the template
11027 with the more cv-qualified argument wins for that pairing (if
11028 neither is more cv-qualified, they both are equal). Unlike regular
11029 deduction, after all the arguments have been deduced in this way,
11030 we do *not* verify the deduced template argument values can be
11031 substituted into non-deduced contexts, nor do we have to verify
11032 that all template arguments have been deduced. */
11035 more_specialized_fn (tree pat1, tree pat2, int len)
11037 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
11038 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
11039 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
11040 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
11041 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
11042 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
11043 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
11044 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
11048 /* Remove the this parameter from non-static member functions. If
11049 one is a non-static member function and the other is not a static
11050 member function, remove the first parameter from that function
11051 also. This situation occurs for operator functions where we
11052 locate both a member function (with this pointer) and non-member
11053 operator (with explicit first operand). */
11054 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
11056 len--; /* LEN is the number of significant arguments for DECL1 */
11057 args1 = TREE_CHAIN (args1);
11058 if (!DECL_STATIC_FUNCTION_P (decl2))
11059 args2 = TREE_CHAIN (args2);
11061 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
11063 args2 = TREE_CHAIN (args2);
11064 if (!DECL_STATIC_FUNCTION_P (decl1))
11067 args1 = TREE_CHAIN (args1);
11071 /* If only one is a conversion operator, they are unordered. */
11072 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
11075 /* Consider the return type for a conversion function */
11076 if (DECL_CONV_FN_P (decl1))
11078 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
11079 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
11083 processing_template_decl++;
11087 tree arg1 = TREE_VALUE (args1);
11088 tree arg2 = TREE_VALUE (args2);
11089 int deduce1, deduce2;
11093 if (TREE_CODE (arg1) == REFERENCE_TYPE)
11095 arg1 = TREE_TYPE (arg1);
11096 quals1 = cp_type_quals (arg1);
11099 if (TREE_CODE (arg2) == REFERENCE_TYPE)
11101 arg2 = TREE_TYPE (arg2);
11102 quals2 = cp_type_quals (arg2);
11105 if ((quals1 < 0) != (quals2 < 0))
11107 /* Only of the args is a reference, see if we should apply
11108 array/function pointer decay to it. This is not part of
11109 DR214, but is, IMHO, consistent with the deduction rules
11110 for the function call itself, and with our earlier
11111 implementation of the underspecified partial ordering
11112 rules. (nathan). */
11115 switch (TREE_CODE (arg1))
11118 arg1 = TREE_TYPE (arg1);
11120 case FUNCTION_TYPE:
11121 arg1 = build_pointer_type (arg1);
11130 switch (TREE_CODE (arg2))
11133 arg2 = TREE_TYPE (arg2);
11135 case FUNCTION_TYPE:
11136 arg2 = build_pointer_type (arg2);
11145 arg1 = TYPE_MAIN_VARIANT (arg1);
11146 arg2 = TYPE_MAIN_VARIANT (arg2);
11148 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
11149 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
11155 if (better1 < 0 && better2 < 0)
11156 /* We've failed to deduce something in either direction.
11157 These must be unordered. */
11160 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
11162 /* Deduces in both directions, see if quals can
11163 disambiguate. Pretend the worse one failed to deduce. */
11164 if ((quals1 & quals2) == quals2)
11166 if ((quals1 & quals2) == quals1)
11169 if (deduce1 && !deduce2 && !better2)
11171 if (deduce2 && !deduce1 && !better1)
11174 args1 = TREE_CHAIN (args1);
11175 args2 = TREE_CHAIN (args2);
11178 processing_template_decl--;
11180 return (better1 > 0) - (better2 > 0);
11183 /* Determine which of two partial specializations is more specialized.
11185 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
11186 to the first partial specialization. The TREE_VALUE is the
11187 innermost set of template parameters for the partial
11188 specialization. PAT2 is similar, but for the second template.
11190 Return 1 if the first partial specialization is more specialized;
11191 -1 if the second is more specialized; 0 if neither is more
11194 See [temp.class.order] for information about determining which of
11195 two templates is more specialized. */
11198 more_specialized_class (tree pat1, tree pat2)
11204 tmpl1 = TREE_TYPE (pat1);
11205 tmpl2 = TREE_TYPE (pat2);
11207 /* Just like what happens for functions, if we are ordering between
11208 different class template specializations, we may encounter dependent
11209 types in the arguments, and we need our dependency check functions
11210 to behave correctly. */
11211 ++processing_template_decl;
11212 targs = get_class_bindings (TREE_VALUE (pat1),
11213 CLASSTYPE_TI_ARGS (tmpl1),
11214 CLASSTYPE_TI_ARGS (tmpl2));
11218 targs = get_class_bindings (TREE_VALUE (pat2),
11219 CLASSTYPE_TI_ARGS (tmpl2),
11220 CLASSTYPE_TI_ARGS (tmpl1));
11223 --processing_template_decl;
11228 /* Return the template arguments that will produce the function signature
11229 DECL from the function template FN, with the explicit template
11230 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
11231 also match. Return NULL_TREE if no satisfactory arguments could be
11235 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
11237 int ntparms = DECL_NTPARMS (fn);
11238 tree targs = make_tree_vec (ntparms);
11240 tree decl_arg_types;
11242 /* Substitute the explicit template arguments into the type of DECL.
11243 The call to fn_type_unification will handle substitution into the
11245 decl_type = TREE_TYPE (decl);
11246 if (explicit_args && uses_template_parms (decl_type))
11249 tree converted_args;
11251 if (DECL_TEMPLATE_INFO (decl))
11252 tmpl = DECL_TI_TEMPLATE (decl);
11254 /* We can get here for some invalid specializations. */
11258 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
11259 explicit_args, NULL_TREE,
11261 /*require_all_args=*/false,
11262 /*use_default_args=*/false);
11263 if (converted_args == error_mark_node)
11266 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
11267 if (decl_type == error_mark_node)
11271 /* Never do unification on the 'this' parameter. */
11272 decl_arg_types = skip_artificial_parms_for (decl,
11273 TYPE_ARG_TYPES (decl_type));
11275 if (fn_type_unification (fn, explicit_args, targs,
11277 (check_rettype || DECL_CONV_FN_P (fn)
11278 ? TREE_TYPE (decl_type) : NULL_TREE),
11279 DEDUCE_EXACT, LOOKUP_NORMAL))
11285 /* Return the innermost template arguments that, when applied to a
11286 template specialization whose innermost template parameters are
11287 TPARMS, and whose specialization arguments are PARMS, yield the
11290 For example, suppose we have:
11292 template <class T, class U> struct S {};
11293 template <class T> struct S<T*, int> {};
11295 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
11296 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
11297 int}. The resulting vector will be {double}, indicating that `T'
11298 is bound to `double'. */
11301 get_class_bindings (tree tparms, tree spec_args, tree args)
11303 int i, ntparms = TREE_VEC_LENGTH (tparms);
11305 tree innermost_deduced_args;
11307 innermost_deduced_args = make_tree_vec (ntparms);
11308 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
11310 deduced_args = copy_node (args);
11311 SET_TMPL_ARGS_LEVEL (deduced_args,
11312 TMPL_ARGS_DEPTH (deduced_args),
11313 innermost_deduced_args);
11316 deduced_args = innermost_deduced_args;
11318 if (unify (tparms, deduced_args,
11319 INNERMOST_TEMPLATE_ARGS (spec_args),
11320 INNERMOST_TEMPLATE_ARGS (args),
11324 for (i = 0; i < ntparms; ++i)
11325 if (! TREE_VEC_ELT (innermost_deduced_args, i))
11328 /* Verify that nondeduced template arguments agree with the type
11329 obtained from argument deduction.
11333 struct A { typedef int X; };
11334 template <class T, class U> struct C {};
11335 template <class T> struct C<T, typename T::X> {};
11337 Then with the instantiation `C<A, int>', we can deduce that
11338 `T' is `A' but unify () does not check whether `typename T::X'
11340 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
11341 if (spec_args == error_mark_node
11342 /* We only need to check the innermost arguments; the other
11343 arguments will always agree. */
11344 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
11345 INNERMOST_TEMPLATE_ARGS (args)))
11348 return deduced_args;
11351 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
11352 Return the TREE_LIST node with the most specialized template, if
11353 any. If there is no most specialized template, the error_mark_node
11356 Note that this function does not look at, or modify, the
11357 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
11358 returned is one of the elements of INSTANTIATIONS, callers may
11359 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
11360 and retrieve it from the value returned. */
11363 most_specialized_instantiation (tree templates)
11367 ++processing_template_decl;
11370 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
11374 if (get_bindings (TREE_VALUE (champ),
11375 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11376 NULL_TREE, /*check_ret=*/false))
11379 if (get_bindings (TREE_VALUE (fn),
11380 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11381 NULL_TREE, /*check_ret=*/false))
11388 /* Equally specialized, move to next function. If there
11389 is no next function, nothing's most specialized. */
11390 fn = TREE_CHAIN (fn);
11398 /* Now verify that champ is better than everything earlier in the
11399 instantiation list. */
11400 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
11401 if (get_bindings (TREE_VALUE (champ),
11402 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
11403 NULL_TREE, /*check_ret=*/false)
11404 || !get_bindings (TREE_VALUE (fn),
11405 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
11406 NULL_TREE, /*check_ret=*/false))
11412 processing_template_decl--;
11415 return error_mark_node;
11420 /* If DECL is a specialization of some template, return the most
11421 general such template. Otherwise, returns NULL_TREE.
11423 For example, given:
11425 template <class T> struct S { template <class U> void f(U); };
11427 if TMPL is `template <class U> void S<int>::f(U)' this will return
11428 the full template. This function will not trace past partial
11429 specializations, however. For example, given in addition:
11431 template <class T> struct S<T*> { template <class U> void f(U); };
11433 if TMPL is `template <class U> void S<int*>::f(U)' this will return
11434 `template <class T> template <class U> S<T*>::f(U)'. */
11437 most_general_template (tree decl)
11439 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
11440 an immediate specialization. */
11441 if (TREE_CODE (decl) == FUNCTION_DECL)
11443 if (DECL_TEMPLATE_INFO (decl)) {
11444 decl = DECL_TI_TEMPLATE (decl);
11446 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
11447 template friend. */
11448 if (TREE_CODE (decl) != TEMPLATE_DECL)
11454 /* Look for more and more general templates. */
11455 while (DECL_TEMPLATE_INFO (decl))
11457 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
11458 (See cp-tree.h for details.) */
11459 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
11462 if (CLASS_TYPE_P (TREE_TYPE (decl))
11463 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
11466 /* Stop if we run into an explicitly specialized class template. */
11467 if (!DECL_NAMESPACE_SCOPE_P (decl)
11468 && DECL_CONTEXT (decl)
11469 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
11472 decl = DECL_TI_TEMPLATE (decl);
11478 /* Return the most specialized of the class template partial
11479 specializations of TMPL which can produce TYPE, a specialization of
11480 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
11481 a _TYPE node corresponding to the partial specialization, while the
11482 TREE_PURPOSE is the set of template arguments that must be
11483 substituted into the TREE_TYPE in order to generate TYPE.
11485 If the choice of partial specialization is ambiguous, a diagnostic
11486 is issued, and the error_mark_node is returned. If there are no
11487 partial specializations of TMPL matching TYPE, then NULL_TREE is
11491 most_specialized_class (tree type, tree tmpl)
11493 tree list = NULL_TREE;
11500 tmpl = most_general_template (tmpl);
11501 args = CLASSTYPE_TI_ARGS (type);
11502 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
11504 tree partial_spec_args;
11507 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
11508 spec_args = get_class_bindings (TREE_VALUE (t),
11513 list = tree_cons (spec_args, TREE_VALUE (t), list);
11514 TREE_TYPE (list) = TREE_TYPE (t);
11521 ambiguous_p = false;
11524 t = TREE_CHAIN (t);
11525 for (; t; t = TREE_CHAIN (t))
11527 fate = more_specialized_class (champ, t);
11534 t = TREE_CHAIN (t);
11537 ambiguous_p = true;
11546 for (t = list; t && t != champ; t = TREE_CHAIN (t))
11548 fate = more_specialized_class (champ, t);
11551 ambiguous_p = true;
11558 const char *str = "candidates are:";
11559 error ("ambiguous class template instantiation for %q#T", type);
11560 for (t = list; t; t = TREE_CHAIN (t))
11562 error ("%s %+#T", str, TREE_TYPE (t));
11565 return error_mark_node;
11571 /* Explicitly instantiate DECL. */
11574 do_decl_instantiation (tree decl, tree storage)
11576 tree result = NULL_TREE;
11579 if (!decl || decl == error_mark_node)
11580 /* An error occurred, for which grokdeclarator has already issued
11581 an appropriate message. */
11583 else if (! DECL_LANG_SPECIFIC (decl))
11585 error ("explicit instantiation of non-template %q#D", decl);
11588 else if (TREE_CODE (decl) == VAR_DECL)
11590 /* There is an asymmetry here in the way VAR_DECLs and
11591 FUNCTION_DECLs are handled by grokdeclarator. In the case of
11592 the latter, the DECL we get back will be marked as a
11593 template instantiation, and the appropriate
11594 DECL_TEMPLATE_INFO will be set up. This does not happen for
11595 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
11596 should handle VAR_DECLs as it currently handles
11598 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
11599 if (!result || TREE_CODE (result) != VAR_DECL)
11601 error ("no matching template for %qD found", decl);
11604 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
11606 error ("type %qT for explicit instantiation %qD does not match "
11607 "declared type %qT", TREE_TYPE (result), decl,
11612 else if (TREE_CODE (decl) != FUNCTION_DECL)
11614 error ("explicit instantiation of %q#D", decl);
11620 /* Check for various error cases. Note that if the explicit
11621 instantiation is valid the RESULT will currently be marked as an
11622 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
11623 until we get here. */
11625 if (DECL_TEMPLATE_SPECIALIZATION (result))
11627 /* DR 259 [temp.spec].
11629 Both an explicit instantiation and a declaration of an explicit
11630 specialization shall not appear in a program unless the explicit
11631 instantiation follows a declaration of the explicit specialization.
11633 For a given set of template parameters, if an explicit
11634 instantiation of a template appears after a declaration of an
11635 explicit specialization for that template, the explicit
11636 instantiation has no effect. */
11639 else if (DECL_EXPLICIT_INSTANTIATION (result))
11643 No program shall explicitly instantiate any template more
11646 We check DECL_NOT_REALLY_EXTERN so as not to complain when
11647 the first instantiation was `extern' and the second is not,
11648 and EXTERN_P for the opposite case. */
11649 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
11650 pedwarn ("duplicate explicit instantiation of %q#D", result);
11651 /* If an "extern" explicit instantiation follows an ordinary
11652 explicit instantiation, the template is instantiated. */
11656 else if (!DECL_IMPLICIT_INSTANTIATION (result))
11658 error ("no matching template for %qD found", result);
11661 else if (!DECL_TEMPLATE_INFO (result))
11663 pedwarn ("explicit instantiation of non-template %q#D", result);
11667 if (storage == NULL_TREE)
11669 else if (storage == ridpointers[(int) RID_EXTERN])
11671 if (pedantic && !in_system_header)
11672 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
11677 error ("storage class %qD applied to template instantiation", storage);
11679 check_explicit_instantiation_namespace (result);
11680 mark_decl_instantiated (result, extern_p);
11682 instantiate_decl (result, /*defer_ok=*/1,
11683 /*expl_inst_class_mem_p=*/false);
11687 mark_class_instantiated (tree t, int extern_p)
11689 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
11690 SET_CLASSTYPE_INTERFACE_KNOWN (t);
11691 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
11692 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
11695 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
11696 rest_of_type_compilation (t, 1);
11700 /* Called from do_type_instantiation through binding_table_foreach to
11701 do recursive instantiation for the type bound in ENTRY. */
11703 bt_instantiate_type_proc (binding_entry entry, void *data)
11705 tree storage = *(tree *) data;
11707 if (IS_AGGR_TYPE (entry->type)
11708 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
11709 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
11712 /* Called from do_type_instantiation to instantiate a member
11713 (a member function or a static member variable) of an
11714 explicitly instantiated class template. */
11716 instantiate_class_member (tree decl, int extern_p)
11718 mark_decl_instantiated (decl, extern_p);
11720 instantiate_decl (decl, /*defer_ok=*/1,
11721 /*expl_inst_class_mem_p=*/true);
11724 /* Perform an explicit instantiation of template class T. STORAGE, if
11725 non-null, is the RID for extern, inline or static. COMPLAIN is
11726 nonzero if this is called from the parser, zero if called recursively,
11727 since the standard is unclear (as detailed below). */
11730 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
11735 int previous_instantiation_extern_p = 0;
11737 if (TREE_CODE (t) == TYPE_DECL)
11740 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
11742 error ("explicit instantiation of non-template type %qT", t);
11748 if (!COMPLETE_TYPE_P (t))
11750 if (complain & tf_error)
11751 error ("explicit instantiation of %q#T before definition of template",
11756 if (storage != NULL_TREE)
11758 if (pedantic && !in_system_header)
11759 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
11762 if (storage == ridpointers[(int) RID_INLINE])
11764 else if (storage == ridpointers[(int) RID_EXTERN])
11766 else if (storage == ridpointers[(int) RID_STATIC])
11770 error ("storage class %qD applied to template instantiation",
11776 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
11778 /* DR 259 [temp.spec].
11780 Both an explicit instantiation and a declaration of an explicit
11781 specialization shall not appear in a program unless the explicit
11782 instantiation follows a declaration of the explicit specialization.
11784 For a given set of template parameters, if an explicit
11785 instantiation of a template appears after a declaration of an
11786 explicit specialization for that template, the explicit
11787 instantiation has no effect. */
11790 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
11794 No program shall explicitly instantiate any template more
11797 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
11798 instantiation was `extern'. If EXTERN_P then the second is.
11799 These cases are OK. */
11800 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
11802 if (!previous_instantiation_extern_p && !extern_p
11803 && (complain & tf_error))
11804 pedwarn ("duplicate explicit instantiation of %q#T", t);
11806 /* If we've already instantiated the template, just return now. */
11807 if (!CLASSTYPE_INTERFACE_ONLY (t))
11811 check_explicit_instantiation_namespace (TYPE_NAME (t));
11812 mark_class_instantiated (t, extern_p);
11820 /* In contrast to implicit instantiation, where only the
11821 declarations, and not the definitions, of members are
11822 instantiated, we have here:
11826 The explicit instantiation of a class template specialization
11827 implies the instantiation of all of its members not
11828 previously explicitly specialized in the translation unit
11829 containing the explicit instantiation.
11831 Of course, we can't instantiate member template classes, since
11832 we don't have any arguments for them. Note that the standard
11833 is unclear on whether the instantiation of the members are
11834 *explicit* instantiations or not. However, the most natural
11835 interpretation is that it should be an explicit instantiation. */
11838 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
11839 if (TREE_CODE (tmp) == FUNCTION_DECL
11840 && DECL_TEMPLATE_INSTANTIATION (tmp))
11841 instantiate_class_member (tmp, extern_p);
11843 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
11844 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
11845 instantiate_class_member (tmp, extern_p);
11847 if (CLASSTYPE_NESTED_UTDS (t))
11848 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
11849 bt_instantiate_type_proc, &storage);
11853 /* Given a function DECL, which is a specialization of TMPL, modify
11854 DECL to be a re-instantiation of TMPL with the same template
11855 arguments. TMPL should be the template into which tsubst'ing
11856 should occur for DECL, not the most general template.
11858 One reason for doing this is a scenario like this:
11861 void f(const T&, int i);
11863 void g() { f(3, 7); }
11866 void f(const T& t, const int i) { }
11868 Note that when the template is first instantiated, with
11869 instantiate_template, the resulting DECL will have no name for the
11870 first parameter, and the wrong type for the second. So, when we go
11871 to instantiate the DECL, we regenerate it. */
11874 regenerate_decl_from_template (tree decl, tree tmpl)
11876 /* The arguments used to instantiate DECL, from the most general
11881 args = DECL_TI_ARGS (decl);
11882 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
11884 /* Make sure that we can see identifiers, and compute access
11886 push_access_scope (decl);
11888 if (TREE_CODE (decl) == FUNCTION_DECL)
11896 args_depth = TMPL_ARGS_DEPTH (args);
11897 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
11898 if (args_depth > parms_depth)
11899 args = get_innermost_template_args (args, parms_depth);
11901 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
11902 args, tf_error, NULL_TREE);
11904 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
11907 /* Merge parameter declarations. */
11908 decl_parm = skip_artificial_parms_for (decl,
11909 DECL_ARGUMENTS (decl));
11911 = skip_artificial_parms_for (code_pattern,
11912 DECL_ARGUMENTS (code_pattern));
11918 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
11919 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
11920 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
11922 parm_type = type_decays_to (parm_type);
11923 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
11924 TREE_TYPE (decl_parm) = parm_type;
11925 attributes = DECL_ATTRIBUTES (pattern_parm);
11926 if (DECL_ATTRIBUTES (decl_parm) != attributes)
11928 DECL_ATTRIBUTES (decl_parm) = attributes;
11929 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
11931 decl_parm = TREE_CHAIN (decl_parm);
11932 pattern_parm = TREE_CHAIN (pattern_parm);
11935 /* Merge additional specifiers from the CODE_PATTERN. */
11936 if (DECL_DECLARED_INLINE_P (code_pattern)
11937 && !DECL_DECLARED_INLINE_P (decl))
11938 DECL_DECLARED_INLINE_P (decl) = 1;
11939 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
11940 DECL_INLINE (decl) = 1;
11942 else if (TREE_CODE (decl) == VAR_DECL)
11943 DECL_INITIAL (decl) =
11944 tsubst_expr (DECL_INITIAL (code_pattern), args,
11945 tf_error, DECL_TI_TEMPLATE (decl),
11946 /*integral_constant_expression_p=*/false);
11948 gcc_unreachable ();
11950 pop_access_scope (decl);
11953 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
11954 substituted to get DECL. */
11957 template_for_substitution (tree decl)
11959 tree tmpl = DECL_TI_TEMPLATE (decl);
11961 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
11962 for the instantiation. This is not always the most general
11963 template. Consider, for example:
11966 struct S { template <class U> void f();
11967 template <> void f<int>(); };
11969 and an instantiation of S<double>::f<int>. We want TD to be the
11970 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11971 while (/* An instantiation cannot have a definition, so we need a
11972 more general template. */
11973 DECL_TEMPLATE_INSTANTIATION (tmpl)
11974 /* We must also deal with friend templates. Given:
11976 template <class T> struct S {
11977 template <class U> friend void f() {};
11980 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
11981 so far as the language is concerned, but that's still
11982 where we get the pattern for the instantiation from. On
11983 other hand, if the definition comes outside the class, say:
11985 template <class T> struct S {
11986 template <class U> friend void f();
11988 template <class U> friend void f() {}
11990 we don't need to look any further. That's what the check for
11991 DECL_INITIAL is for. */
11992 || (TREE_CODE (decl) == FUNCTION_DECL
11993 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
11994 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
11996 /* The present template, TD, should not be a definition. If it
11997 were a definition, we should be using it! Note that we
11998 cannot restructure the loop to just keep going until we find
11999 a template with a definition, since that might go too far if
12000 a specialization was declared, but not defined. */
12001 gcc_assert (TREE_CODE (decl) != VAR_DECL
12002 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
12004 /* Fetch the more general template. */
12005 tmpl = DECL_TI_TEMPLATE (tmpl);
12011 /* Produce the definition of D, a _DECL generated from a template. If
12012 DEFER_OK is nonzero, then we don't have to actually do the
12013 instantiation now; we just have to do it sometime. Normally it is
12014 an error if this is an explicit instantiation but D is undefined.
12015 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
12016 explicitly instantiated class template. */
12019 instantiate_decl (tree d, int defer_ok,
12020 bool expl_inst_class_mem_p)
12022 tree tmpl = DECL_TI_TEMPLATE (d);
12029 bool pattern_defined;
12031 location_t saved_loc = input_location;
12034 /* This function should only be used to instantiate templates for
12035 functions and static member variables. */
12036 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
12037 || TREE_CODE (d) == VAR_DECL);
12039 /* Variables are never deferred; if instantiation is required, they
12040 are instantiated right away. That allows for better code in the
12041 case that an expression refers to the value of the variable --
12042 if the variable has a constant value the referring expression can
12043 take advantage of that fact. */
12044 if (TREE_CODE (d) == VAR_DECL)
12047 /* Don't instantiate cloned functions. Instead, instantiate the
12048 functions they cloned. */
12049 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
12050 d = DECL_CLONED_FUNCTION (d);
12052 if (DECL_TEMPLATE_INSTANTIATED (d))
12053 /* D has already been instantiated. It might seem reasonable to
12054 check whether or not D is an explicit instantiation, and, if so,
12055 stop here. But when an explicit instantiation is deferred
12056 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
12057 is set, even though we still need to do the instantiation. */
12060 /* If we already have a specialization of this declaration, then
12061 there's no reason to instantiate it. Note that
12062 retrieve_specialization gives us both instantiations and
12063 specializations, so we must explicitly check
12064 DECL_TEMPLATE_SPECIALIZATION. */
12065 gen_tmpl = most_general_template (tmpl);
12066 gen_args = DECL_TI_ARGS (d);
12067 spec = retrieve_specialization (gen_tmpl, gen_args,
12068 /*class_specializations_p=*/false);
12069 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
12072 /* This needs to happen before any tsubsting. */
12073 if (! push_tinst_level (d))
12076 timevar_push (TV_PARSE);
12078 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
12079 for the instantiation. */
12080 td = template_for_substitution (d);
12081 code_pattern = DECL_TEMPLATE_RESULT (td);
12083 /* We should never be trying to instantiate a member of a class
12084 template or partial specialization. */
12085 gcc_assert (d != code_pattern);
12087 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
12088 || DECL_TEMPLATE_SPECIALIZATION (td))
12089 /* In the case of a friend template whose definition is provided
12090 outside the class, we may have too many arguments. Drop the
12091 ones we don't need. The same is true for specializations. */
12092 args = get_innermost_template_args
12093 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
12097 if (TREE_CODE (d) == FUNCTION_DECL)
12098 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
12100 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
12102 /* We may be in the middle of deferred access check. Disable it now. */
12103 push_deferring_access_checks (dk_no_deferred);
12105 /* Unless an explicit instantiation directive has already determined
12106 the linkage of D, remember that a definition is available for
12108 if (pattern_defined
12109 && !DECL_INTERFACE_KNOWN (d)
12110 && !DECL_NOT_REALLY_EXTERN (d))
12111 mark_definable (d);
12113 input_location = DECL_SOURCE_LOCATION (d);
12115 /* If D is a member of an explicitly instantiated class template,
12116 and no definition is available, treat it like an implicit
12118 if (!pattern_defined && expl_inst_class_mem_p
12119 && DECL_EXPLICIT_INSTANTIATION (d))
12121 DECL_NOT_REALLY_EXTERN (d) = 0;
12122 DECL_INTERFACE_KNOWN (d) = 0;
12123 SET_DECL_IMPLICIT_INSTANTIATION (d);
12128 /* Recheck the substitutions to obtain any warning messages
12129 about ignoring cv qualifiers. */
12130 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
12131 tree type = TREE_TYPE (gen);
12133 /* Make sure that we can see identifiers, and compute access
12134 correctly. D is already the target FUNCTION_DECL with the
12136 push_access_scope (d);
12138 if (TREE_CODE (gen) == FUNCTION_DECL)
12140 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
12141 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
12142 tf_warning_or_error, d);
12143 /* Don't simply tsubst the function type, as that will give
12144 duplicate warnings about poor parameter qualifications.
12145 The function arguments are the same as the decl_arguments
12146 without the top level cv qualifiers. */
12147 type = TREE_TYPE (type);
12149 tsubst (type, gen_args, tf_warning_or_error, d);
12151 pop_access_scope (d);
12154 /* Check to see whether we know that this template will be
12155 instantiated in some other file, as with "extern template"
12157 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
12158 /* In general, we do not instantiate such templates... */
12160 /* ... but we instantiate inline functions so that we can inline
12162 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
12163 /* ... we instantiate static data members whose values are
12164 needed in integral constant expressions. */
12165 && ! (TREE_CODE (d) == VAR_DECL
12166 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
12168 /* Defer all other templates, unless we have been explicitly
12169 forbidden from doing so. */
12170 if (/* If there is no definition, we cannot instantiate the
12173 /* If it's OK to postpone instantiation, do so. */
12175 /* If this is a static data member that will be defined
12176 elsewhere, we don't want to instantiate the entire data
12177 member, but we do want to instantiate the initializer so that
12178 we can substitute that elsewhere. */
12179 || (external_p && TREE_CODE (d) == VAR_DECL))
12181 /* The definition of the static data member is now required so
12182 we must substitute the initializer. */
12183 if (TREE_CODE (d) == VAR_DECL
12184 && !DECL_INITIAL (d)
12185 && DECL_INITIAL (code_pattern))
12190 ns = decl_namespace_context (d);
12191 push_nested_namespace (ns);
12192 push_nested_class (DECL_CONTEXT (d));
12193 init = tsubst_expr (DECL_INITIAL (code_pattern),
12195 tf_warning_or_error, NULL_TREE,
12196 /*integral_constant_expression_p=*/false);
12197 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
12198 /*asmspec_tree=*/NULL_TREE,
12199 LOOKUP_ONLYCONVERTING);
12200 pop_nested_class ();
12201 pop_nested_namespace (ns);
12204 /* We restore the source position here because it's used by
12205 add_pending_template. */
12206 input_location = saved_loc;
12208 if (at_eof && !pattern_defined
12209 && DECL_EXPLICIT_INSTANTIATION (d))
12212 The definition of a non-exported function template, a
12213 non-exported member function template, or a non-exported
12214 member function or static data member of a class template
12215 shall be present in every translation unit in which it is
12216 explicitly instantiated. */
12218 ("explicit instantiation of %qD but no definition available", d);
12220 /* ??? Historically, we have instantiated inline functions, even
12221 when marked as "extern template". */
12222 if (!(external_p && TREE_CODE (d) == VAR_DECL))
12223 add_pending_template (d);
12226 /* Tell the repository that D is available in this translation unit
12227 -- and see if it is supposed to be instantiated here. */
12228 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
12230 /* In a PCH file, despite the fact that the repository hasn't
12231 requested instantiation in the PCH it is still possible that
12232 an instantiation will be required in a file that includes the
12235 add_pending_template (d);
12236 /* Instantiate inline functions so that the inliner can do its
12237 job, even though we'll not be emitting a copy of this
12239 if (!(TREE_CODE (d) == FUNCTION_DECL
12240 && flag_inline_trees
12241 && DECL_DECLARED_INLINE_P (d)))
12245 need_push = !cfun || !global_bindings_p ();
12247 push_to_top_level ();
12249 /* Mark D as instantiated so that recursive calls to
12250 instantiate_decl do not try to instantiate it again. */
12251 DECL_TEMPLATE_INSTANTIATED (d) = 1;
12253 /* Regenerate the declaration in case the template has been modified
12254 by a subsequent redeclaration. */
12255 regenerate_decl_from_template (d, td);
12257 /* We already set the file and line above. Reset them now in case
12258 they changed as a result of calling regenerate_decl_from_template. */
12259 input_location = DECL_SOURCE_LOCATION (d);
12261 if (TREE_CODE (d) == VAR_DECL)
12265 /* Clear out DECL_RTL; whatever was there before may not be right
12266 since we've reset the type of the declaration. */
12267 SET_DECL_RTL (d, NULL_RTX);
12268 DECL_IN_AGGR_P (d) = 0;
12270 /* The initializer is placed in DECL_INITIAL by
12271 regenerate_decl_from_template. Pull it out so that
12272 finish_decl can process it. */
12273 init = DECL_INITIAL (d);
12274 DECL_INITIAL (d) = NULL_TREE;
12275 DECL_INITIALIZED_P (d) = 0;
12277 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
12278 initializer. That function will defer actual emission until
12279 we have a chance to determine linkage. */
12280 DECL_EXTERNAL (d) = 0;
12282 /* Enter the scope of D so that access-checking works correctly. */
12283 push_nested_class (DECL_CONTEXT (d));
12284 finish_decl (d, init, NULL_TREE);
12285 pop_nested_class ();
12287 else if (TREE_CODE (d) == FUNCTION_DECL)
12289 htab_t saved_local_specializations;
12294 /* Save away the current list, in case we are instantiating one
12295 template from within the body of another. */
12296 saved_local_specializations = local_specializations;
12298 /* Set up the list of local specializations. */
12299 local_specializations = htab_create (37,
12300 hash_local_specialization,
12301 eq_local_specializations,
12304 /* Set up context. */
12305 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
12307 /* Create substitution entries for the parameters. */
12308 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
12309 tmpl_parm = DECL_ARGUMENTS (subst_decl);
12310 spec_parm = DECL_ARGUMENTS (d);
12311 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
12313 register_local_specialization (spec_parm, tmpl_parm);
12314 spec_parm = skip_artificial_parms_for (d, spec_parm);
12315 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
12319 register_local_specialization (spec_parm, tmpl_parm);
12320 tmpl_parm = TREE_CHAIN (tmpl_parm);
12321 spec_parm = TREE_CHAIN (spec_parm);
12323 gcc_assert (!spec_parm);
12325 /* Substitute into the body of the function. */
12326 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
12327 tf_warning_or_error, tmpl,
12328 /*integral_constant_expression_p=*/false);
12330 /* We don't need the local specializations any more. */
12331 htab_delete (local_specializations);
12332 local_specializations = saved_local_specializations;
12334 /* Finish the function. */
12335 d = finish_function (0);
12336 expand_or_defer_fn (d);
12339 /* We're not deferring instantiation any more. */
12340 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
12343 pop_from_top_level ();
12346 input_location = saved_loc;
12347 pop_deferring_access_checks ();
12348 pop_tinst_level ();
12350 timevar_pop (TV_PARSE);
12355 /* Run through the list of templates that we wish we could
12356 instantiate, and instantiate any we can. RETRIES is the
12357 number of times we retry pending template instantiation. */
12360 instantiate_pending_templates (int retries)
12363 tree last = NULL_TREE;
12365 location_t saved_loc = input_location;
12366 int saved_in_system_header = in_system_header;
12368 /* Instantiating templates may trigger vtable generation. This in turn
12369 may require further template instantiations. We place a limit here
12370 to avoid infinite loop. */
12371 if (pending_templates && retries >= max_tinst_depth)
12373 tree decl = TREE_VALUE (pending_templates);
12375 error ("template instantiation depth exceeds maximum of %d"
12376 " instantiating %q+D, possibly from virtual table generation"
12377 " (use -ftemplate-depth-NN to increase the maximum)",
12378 max_tinst_depth, decl);
12379 if (TREE_CODE (decl) == FUNCTION_DECL)
12380 /* Pretend that we defined it. */
12381 DECL_INITIAL (decl) = error_mark_node;
12389 t = &pending_templates;
12392 tree instantiation = TREE_VALUE (*t);
12394 reopen_tinst_level (TREE_PURPOSE (*t));
12396 if (TYPE_P (instantiation))
12400 if (!COMPLETE_TYPE_P (instantiation))
12402 instantiate_class_template (instantiation);
12403 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
12404 for (fn = TYPE_METHODS (instantiation);
12406 fn = TREE_CHAIN (fn))
12407 if (! DECL_ARTIFICIAL (fn))
12408 instantiate_decl (fn,
12410 /*expl_inst_class_mem_p=*/false);
12411 if (COMPLETE_TYPE_P (instantiation))
12415 if (COMPLETE_TYPE_P (instantiation))
12416 /* If INSTANTIATION has been instantiated, then we don't
12417 need to consider it again in the future. */
12418 *t = TREE_CHAIN (*t);
12422 t = &TREE_CHAIN (*t);
12427 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
12428 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
12431 = instantiate_decl (instantiation,
12433 /*expl_inst_class_mem_p=*/false);
12434 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
12438 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
12439 || DECL_TEMPLATE_INSTANTIATED (instantiation))
12440 /* If INSTANTIATION has been instantiated, then we don't
12441 need to consider it again in the future. */
12442 *t = TREE_CHAIN (*t);
12446 t = &TREE_CHAIN (*t);
12450 current_tinst_level = NULL_TREE;
12452 last_pending_template = last;
12454 while (reconsider);
12456 input_location = saved_loc;
12457 in_system_header = saved_in_system_header;
12460 /* Substitute ARGVEC into T, which is a list of initializers for
12461 either base class or a non-static data member. The TREE_PURPOSEs
12462 are DECLs, and the TREE_VALUEs are the initializer values. Used by
12463 instantiate_decl. */
12466 tsubst_initializer_list (tree t, tree argvec)
12468 tree inits = NULL_TREE;
12470 for (; t; t = TREE_CHAIN (t))
12475 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_warning_or_error,
12477 decl = expand_member_init (decl);
12478 if (decl && !DECL_P (decl))
12479 in_base_initializer = 1;
12481 init = tsubst_expr (TREE_VALUE (t), argvec, tf_warning_or_error,
12483 /*integral_constant_expression_p=*/false);
12484 in_base_initializer = 0;
12488 init = build_tree_list (decl, init);
12489 TREE_CHAIN (init) = inits;
12496 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
12499 set_current_access_from_decl (tree decl)
12501 if (TREE_PRIVATE (decl))
12502 current_access_specifier = access_private_node;
12503 else if (TREE_PROTECTED (decl))
12504 current_access_specifier = access_protected_node;
12506 current_access_specifier = access_public_node;
12509 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
12510 is the instantiation (which should have been created with
12511 start_enum) and ARGS are the template arguments to use. */
12514 tsubst_enum (tree tag, tree newtag, tree args)
12518 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
12523 decl = TREE_VALUE (e);
12524 /* Note that in a template enum, the TREE_VALUE is the
12525 CONST_DECL, not the corresponding INTEGER_CST. */
12526 value = tsubst_expr (DECL_INITIAL (decl),
12527 args, tf_warning_or_error, NULL_TREE,
12528 /*integral_constant_expression_p=*/true);
12530 /* Give this enumeration constant the correct access. */
12531 set_current_access_from_decl (decl);
12533 /* Actually build the enumerator itself. */
12534 build_enumerator (DECL_NAME (decl), value, newtag);
12537 finish_enum (newtag);
12538 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
12539 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
12542 /* DECL is a FUNCTION_DECL that is a template specialization. Return
12543 its type -- but without substituting the innermost set of template
12544 arguments. So, innermost set of template parameters will appear in
12548 get_mostly_instantiated_function_type (tree decl)
12556 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
12557 targs = DECL_TI_ARGS (decl);
12558 tparms = DECL_TEMPLATE_PARMS (tmpl);
12559 parm_depth = TMPL_PARMS_DEPTH (tparms);
12561 /* There should be as many levels of arguments as there are levels
12563 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
12565 fn_type = TREE_TYPE (tmpl);
12567 if (parm_depth == 1)
12568 /* No substitution is necessary. */
12572 int i, save_access_control;
12575 /* Replace the innermost level of the TARGS with NULL_TREEs to
12576 let tsubst know not to substitute for those parameters. */
12577 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
12578 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
12579 SET_TMPL_ARGS_LEVEL (partial_args, i,
12580 TMPL_ARGS_LEVEL (targs, i));
12581 SET_TMPL_ARGS_LEVEL (partial_args,
12582 TMPL_ARGS_DEPTH (targs),
12583 make_tree_vec (DECL_NTPARMS (tmpl)));
12585 /* Disable access control as this function is used only during
12587 save_access_control = flag_access_control;
12588 flag_access_control = 0;
12590 ++processing_template_decl;
12591 /* Now, do the (partial) substitution to figure out the
12592 appropriate function type. */
12593 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
12594 --processing_template_decl;
12596 /* Substitute into the template parameters to obtain the real
12597 innermost set of parameters. This step is important if the
12598 innermost set of template parameters contains value
12599 parameters whose types depend on outer template parameters. */
12600 TREE_VEC_LENGTH (partial_args)--;
12601 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
12603 flag_access_control = save_access_control;
12609 /* Return truthvalue if we're processing a template different from
12610 the last one involved in diagnostics. */
12612 problematic_instantiation_changed (void)
12614 return last_template_error_tick != tinst_level_tick;
12617 /* Remember current template involved in diagnostics. */
12619 record_last_problematic_instantiation (void)
12621 last_template_error_tick = tinst_level_tick;
12625 current_instantiation (void)
12627 return current_tinst_level;
12630 /* [temp.param] Check that template non-type parm TYPE is of an allowable
12631 type. Return zero for ok, nonzero for disallowed. Issue error and
12632 warning messages under control of COMPLAIN. */
12635 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
12637 if (INTEGRAL_TYPE_P (type))
12639 else if (POINTER_TYPE_P (type))
12641 else if (TYPE_PTR_TO_MEMBER_P (type))
12643 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
12645 else if (TREE_CODE (type) == TYPENAME_TYPE)
12648 if (complain & tf_error)
12649 error ("%q#T is not a valid type for a template constant parameter", type);
12653 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
12654 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
12657 dependent_type_p_r (tree type)
12663 A type is dependent if it is:
12665 -- a template parameter. Template template parameters are types
12666 for us (since TYPE_P holds true for them) so we handle
12668 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
12669 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
12671 /* -- a qualified-id with a nested-name-specifier which contains a
12672 class-name that names a dependent type or whose unqualified-id
12673 names a dependent type. */
12674 if (TREE_CODE (type) == TYPENAME_TYPE)
12676 /* -- a cv-qualified type where the cv-unqualified type is
12678 type = TYPE_MAIN_VARIANT (type);
12679 /* -- a compound type constructed from any dependent type. */
12680 if (TYPE_PTR_TO_MEMBER_P (type))
12681 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
12682 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
12684 else if (TREE_CODE (type) == POINTER_TYPE
12685 || TREE_CODE (type) == REFERENCE_TYPE)
12686 return dependent_type_p (TREE_TYPE (type));
12687 else if (TREE_CODE (type) == FUNCTION_TYPE
12688 || TREE_CODE (type) == METHOD_TYPE)
12692 if (dependent_type_p (TREE_TYPE (type)))
12694 for (arg_type = TYPE_ARG_TYPES (type);
12696 arg_type = TREE_CHAIN (arg_type))
12697 if (dependent_type_p (TREE_VALUE (arg_type)))
12701 /* -- an array type constructed from any dependent type or whose
12702 size is specified by a constant expression that is
12703 value-dependent. */
12704 if (TREE_CODE (type) == ARRAY_TYPE)
12706 if (TYPE_DOMAIN (type)
12707 && ((value_dependent_expression_p
12708 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12709 || (type_dependent_expression_p
12710 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
12712 return dependent_type_p (TREE_TYPE (type));
12715 /* -- a template-id in which either the template name is a template
12717 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
12719 /* ... or any of the template arguments is a dependent type or
12720 an expression that is type-dependent or value-dependent. */
12721 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
12722 && (any_dependent_template_arguments_p
12723 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
12726 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
12727 expression is not type-dependent, then it should already been
12729 if (TREE_CODE (type) == TYPEOF_TYPE)
12732 /* The standard does not specifically mention types that are local
12733 to template functions or local classes, but they should be
12734 considered dependent too. For example:
12736 template <int I> void f() {
12741 The size of `E' cannot be known until the value of `I' has been
12742 determined. Therefore, `E' must be considered dependent. */
12743 scope = TYPE_CONTEXT (type);
12744 if (scope && TYPE_P (scope))
12745 return dependent_type_p (scope);
12746 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12747 return type_dependent_expression_p (scope);
12749 /* Other types are non-dependent. */
12753 /* Returns TRUE if TYPE is dependent, in the sense of
12754 [temp.dep.type]. */
12757 dependent_type_p (tree type)
12759 /* If there are no template parameters in scope, then there can't be
12760 any dependent types. */
12761 if (!processing_template_decl)
12763 /* If we are not processing a template, then nobody should be
12764 providing us with a dependent type. */
12766 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
12770 /* If the type is NULL, we have not computed a type for the entity
12771 in question; in that case, the type is dependent. */
12775 /* Erroneous types can be considered non-dependent. */
12776 if (type == error_mark_node)
12779 /* If we have not already computed the appropriate value for TYPE,
12781 if (!TYPE_DEPENDENT_P_VALID (type))
12783 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
12784 TYPE_DEPENDENT_P_VALID (type) = 1;
12787 return TYPE_DEPENDENT_P (type);
12790 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
12793 dependent_scope_ref_p (tree expression, bool criterion (tree))
12798 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
12800 if (!TYPE_P (TREE_OPERAND (expression, 0)))
12803 scope = TREE_OPERAND (expression, 0);
12804 name = TREE_OPERAND (expression, 1);
12808 An id-expression is type-dependent if it contains a
12809 nested-name-specifier that contains a class-name that names a
12811 /* The suggested resolution to Core Issue 2 implies that if the
12812 qualifying type is the current class, then we must peek
12815 && currently_open_class (scope)
12816 && !criterion (name))
12818 if (dependent_type_p (scope))
12824 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
12825 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
12829 value_dependent_expression_p (tree expression)
12831 if (!processing_template_decl)
12834 /* A name declared with a dependent type. */
12835 if (DECL_P (expression) && type_dependent_expression_p (expression))
12838 switch (TREE_CODE (expression))
12840 case IDENTIFIER_NODE:
12841 /* A name that has not been looked up -- must be dependent. */
12844 case TEMPLATE_PARM_INDEX:
12845 /* A non-type template parm. */
12849 /* A non-type template parm. */
12850 if (DECL_TEMPLATE_PARM_P (expression))
12855 /* A constant with integral or enumeration type and is initialized
12856 with an expression that is value-dependent. */
12857 if (DECL_INITIAL (expression)
12858 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
12859 && value_dependent_expression_p (DECL_INITIAL (expression)))
12863 case DYNAMIC_CAST_EXPR:
12864 case STATIC_CAST_EXPR:
12865 case CONST_CAST_EXPR:
12866 case REINTERPRET_CAST_EXPR:
12868 /* These expressions are value-dependent if the type to which
12869 the cast occurs is dependent or the expression being casted
12870 is value-dependent. */
12872 tree type = TREE_TYPE (expression);
12874 if (dependent_type_p (type))
12877 /* A functional cast has a list of operands. */
12878 expression = TREE_OPERAND (expression, 0);
12881 /* If there are no operands, it must be an expression such
12882 as "int()". This should not happen for aggregate types
12883 because it would form non-constant expressions. */
12884 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
12889 if (TREE_CODE (expression) == TREE_LIST)
12891 for (; expression; expression = TREE_CHAIN (expression))
12892 if (value_dependent_expression_p (TREE_VALUE (expression)))
12897 return value_dependent_expression_p (expression);
12902 /* A `sizeof' expression is value-dependent if the operand is
12904 expression = TREE_OPERAND (expression, 0);
12905 if (TYPE_P (expression))
12906 return dependent_type_p (expression);
12907 return type_dependent_expression_p (expression);
12910 return dependent_scope_ref_p (expression, value_dependent_expression_p);
12912 case COMPONENT_REF:
12913 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
12914 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
12917 /* A CALL_EXPR may appear in a constant expression if it is a
12918 call to a builtin function, e.g., __builtin_constant_p. All
12919 such calls are value-dependent. */
12923 /* A constant expression is value-dependent if any subexpression is
12924 value-dependent. */
12925 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
12927 case tcc_reference:
12929 return (value_dependent_expression_p
12930 (TREE_OPERAND (expression, 0)));
12932 case tcc_comparison:
12934 return ((value_dependent_expression_p
12935 (TREE_OPERAND (expression, 0)))
12936 || (value_dependent_expression_p
12937 (TREE_OPERAND (expression, 1))));
12939 case tcc_expression:
12943 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
12944 /* In some cases, some of the operands may be missing.
12945 (For example, in the case of PREDECREMENT_EXPR, the
12946 amount to increment by may be missing.) That doesn't
12947 make the expression dependent. */
12948 if (TREE_OPERAND (expression, i)
12949 && (value_dependent_expression_p
12950 (TREE_OPERAND (expression, i))))
12960 /* The expression is not value-dependent. */
12964 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
12965 [temp.dep.expr]. */
12968 type_dependent_expression_p (tree expression)
12970 if (!processing_template_decl)
12973 if (expression == error_mark_node)
12976 /* An unresolved name is always dependent. */
12977 if (TREE_CODE (expression) == IDENTIFIER_NODE
12978 || TREE_CODE (expression) == USING_DECL)
12981 /* Some expression forms are never type-dependent. */
12982 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
12983 || TREE_CODE (expression) == SIZEOF_EXPR
12984 || TREE_CODE (expression) == ALIGNOF_EXPR
12985 || TREE_CODE (expression) == TYPEID_EXPR
12986 || TREE_CODE (expression) == DELETE_EXPR
12987 || TREE_CODE (expression) == VEC_DELETE_EXPR
12988 || TREE_CODE (expression) == THROW_EXPR)
12991 /* The types of these expressions depends only on the type to which
12992 the cast occurs. */
12993 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
12994 || TREE_CODE (expression) == STATIC_CAST_EXPR
12995 || TREE_CODE (expression) == CONST_CAST_EXPR
12996 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
12997 || TREE_CODE (expression) == CAST_EXPR)
12998 return dependent_type_p (TREE_TYPE (expression));
13000 /* The types of these expressions depends only on the type created
13001 by the expression. */
13002 if (TREE_CODE (expression) == NEW_EXPR
13003 || TREE_CODE (expression) == VEC_NEW_EXPR)
13005 /* For NEW_EXPR tree nodes created inside a template, either
13006 the object type itself or a TREE_LIST may appear as the
13008 tree type = TREE_OPERAND (expression, 1);
13009 if (TREE_CODE (type) == TREE_LIST)
13010 /* This is an array type. We need to check array dimensions
13012 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
13013 || value_dependent_expression_p
13014 (TREE_OPERAND (TREE_VALUE (type), 1));
13016 return dependent_type_p (type);
13019 if (TREE_CODE (expression) == SCOPE_REF
13020 && dependent_scope_ref_p (expression,
13021 type_dependent_expression_p))
13024 if (TREE_CODE (expression) == FUNCTION_DECL
13025 && DECL_LANG_SPECIFIC (expression)
13026 && DECL_TEMPLATE_INFO (expression)
13027 && (any_dependent_template_arguments_p
13028 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
13031 if (TREE_CODE (expression) == TEMPLATE_DECL
13032 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
13035 if (TREE_TYPE (expression) == unknown_type_node)
13037 if (TREE_CODE (expression) == ADDR_EXPR)
13038 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
13039 if (TREE_CODE (expression) == COMPONENT_REF
13040 || TREE_CODE (expression) == OFFSET_REF)
13042 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
13044 expression = TREE_OPERAND (expression, 1);
13045 if (TREE_CODE (expression) == IDENTIFIER_NODE)
13048 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
13049 if (TREE_CODE (expression) == SCOPE_REF)
13052 if (TREE_CODE (expression) == BASELINK)
13053 expression = BASELINK_FUNCTIONS (expression);
13055 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
13057 if (any_dependent_template_arguments_p
13058 (TREE_OPERAND (expression, 1)))
13060 expression = TREE_OPERAND (expression, 0);
13062 gcc_assert (TREE_CODE (expression) == OVERLOAD
13063 || TREE_CODE (expression) == FUNCTION_DECL);
13067 if (type_dependent_expression_p (OVL_CURRENT (expression)))
13069 expression = OVL_NEXT (expression);
13074 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
13076 return (dependent_type_p (TREE_TYPE (expression)));
13079 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
13080 contains a type-dependent expression. */
13083 any_type_dependent_arguments_p (tree args)
13087 tree arg = TREE_VALUE (args);
13089 if (type_dependent_expression_p (arg))
13091 args = TREE_CHAIN (args);
13096 /* Returns TRUE if the ARG (a template argument) is dependent. */
13099 dependent_template_arg_p (tree arg)
13101 if (!processing_template_decl)
13104 if (TREE_CODE (arg) == TEMPLATE_DECL
13105 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
13106 return dependent_template_p (arg);
13107 else if (TYPE_P (arg))
13108 return dependent_type_p (arg);
13110 return (type_dependent_expression_p (arg)
13111 || value_dependent_expression_p (arg));
13114 /* Returns true if ARGS (a collection of template arguments) contains
13115 any types that require structural equality testing. */
13118 any_template_arguments_need_structural_equality_p (tree args)
13125 if (args == error_mark_node)
13128 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
13130 tree level = TMPL_ARGS_LEVEL (args, i + 1);
13131 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
13133 tree arg = TREE_VEC_ELT (level, j);
13134 if (TREE_CODE (arg) == TEMPLATE_DECL
13135 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
13137 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
13139 else if (!TYPE_P (arg) && TREE_TYPE (arg)
13140 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
13148 /* Returns true if ARGS (a collection of template arguments) contains
13149 any dependent arguments. */
13152 any_dependent_template_arguments_p (tree args)
13159 if (args == error_mark_node)
13162 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
13164 tree level = TMPL_ARGS_LEVEL (args, i + 1);
13165 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
13166 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
13173 /* Returns TRUE if the template TMPL is dependent. */
13176 dependent_template_p (tree tmpl)
13178 if (TREE_CODE (tmpl) == OVERLOAD)
13182 if (dependent_template_p (OVL_FUNCTION (tmpl)))
13184 tmpl = OVL_CHAIN (tmpl);
13189 /* Template template parameters are dependent. */
13190 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
13191 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
13193 /* So are names that have not been looked up. */
13194 if (TREE_CODE (tmpl) == SCOPE_REF
13195 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
13197 /* So are member templates of dependent classes. */
13198 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
13199 return dependent_type_p (DECL_CONTEXT (tmpl));
13203 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
13206 dependent_template_id_p (tree tmpl, tree args)
13208 return (dependent_template_p (tmpl)
13209 || any_dependent_template_arguments_p (args));
13212 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
13213 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
13214 can be found. Note that this function peers inside uninstantiated
13215 templates and therefore should be used only in extremely limited
13216 situations. ONLY_CURRENT_P restricts this peering to the currently
13217 open classes hierarchy (which is required when comparing types). */
13220 resolve_typename_type (tree type, bool only_current_p)
13228 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
13230 scope = TYPE_CONTEXT (type);
13231 name = TYPE_IDENTIFIER (type);
13233 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
13234 it first before we can figure out what NAME refers to. */
13235 if (TREE_CODE (scope) == TYPENAME_TYPE)
13236 scope = resolve_typename_type (scope, only_current_p);
13237 /* If we don't know what SCOPE refers to, then we cannot resolve the
13239 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
13240 return error_mark_node;
13241 /* If the SCOPE is a template type parameter, we have no way of
13242 resolving the name. */
13243 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
13245 /* If the SCOPE is not the current instantiation, there's no reason
13246 to look inside it. */
13247 if (only_current_p && !currently_open_class (scope))
13248 return error_mark_node;
13249 /* If SCOPE is a partial instantiation, it will not have a valid
13250 TYPE_FIELDS list, so use the original template. */
13251 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
13252 /* Enter the SCOPE so that name lookup will be resolved as if we
13253 were in the class definition. In particular, SCOPE will no
13254 longer be considered a dependent type. */
13255 pushed_scope = push_scope (scope);
13256 /* Look up the declaration. */
13257 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
13258 /* Obtain the set of qualifiers applied to the TYPE. */
13259 quals = cp_type_quals (type);
13260 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
13261 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
13263 type = error_mark_node;
13264 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
13265 && TREE_CODE (decl) == TYPE_DECL)
13266 type = TREE_TYPE (decl);
13267 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
13268 && DECL_CLASS_TEMPLATE_P (decl))
13272 /* Obtain the template and the arguments. */
13273 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
13274 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
13275 /* Instantiate the template. */
13276 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
13277 /*entering_scope=*/0, tf_error | tf_user);
13280 type = error_mark_node;
13281 /* Qualify the resulting type. */
13282 if (type != error_mark_node && quals)
13283 type = cp_build_qualified_type (type, quals);
13284 /* Leave the SCOPE. */
13286 pop_scope (pushed_scope);
13291 /* EXPR is an expression which is not type-dependent. Return a proxy
13292 for EXPR that can be used to compute the types of larger
13293 expressions containing EXPR. */
13296 build_non_dependent_expr (tree expr)
13300 /* Preserve null pointer constants so that the type of things like
13301 "p == 0" where "p" is a pointer can be determined. */
13302 if (null_ptr_cst_p (expr))
13304 /* Preserve OVERLOADs; the functions must be available to resolve
13307 if (TREE_CODE (inner_expr) == ADDR_EXPR)
13308 inner_expr = TREE_OPERAND (inner_expr, 0);
13309 if (TREE_CODE (inner_expr) == COMPONENT_REF)
13310 inner_expr = TREE_OPERAND (inner_expr, 1);
13311 if (is_overloaded_fn (inner_expr)
13312 || TREE_CODE (inner_expr) == OFFSET_REF)
13314 /* There is no need to return a proxy for a variable. */
13315 if (TREE_CODE (expr) == VAR_DECL)
13317 /* Preserve string constants; conversions from string constants to
13318 "char *" are allowed, even though normally a "const char *"
13319 cannot be used to initialize a "char *". */
13320 if (TREE_CODE (expr) == STRING_CST)
13322 /* Preserve arithmetic constants, as an optimization -- there is no
13323 reason to create a new node. */
13324 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
13326 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
13327 There is at least one place where we want to know that a
13328 particular expression is a throw-expression: when checking a ?:
13329 expression, there are special rules if the second or third
13330 argument is a throw-expression. */
13331 if (TREE_CODE (expr) == THROW_EXPR)
13334 if (TREE_CODE (expr) == COND_EXPR)
13335 return build3 (COND_EXPR,
13337 TREE_OPERAND (expr, 0),
13338 (TREE_OPERAND (expr, 1)
13339 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
13340 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
13341 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
13342 if (TREE_CODE (expr) == COMPOUND_EXPR
13343 && !COMPOUND_EXPR_OVERLOADED (expr))
13344 return build2 (COMPOUND_EXPR,
13346 TREE_OPERAND (expr, 0),
13347 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
13349 /* If the type is unknown, it can't really be non-dependent */
13350 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
13352 /* Otherwise, build a NON_DEPENDENT_EXPR.
13354 REFERENCE_TYPEs are not stripped for expressions in templates
13355 because doing so would play havoc with mangling. Consider, for
13358 template <typename T> void f<T& g>() { g(); }
13360 In the body of "f", the expression for "g" will have
13361 REFERENCE_TYPE, even though the standard says that it should
13362 not. The reason is that we must preserve the syntactic form of
13363 the expression so that mangling (say) "f<g>" inside the body of
13364 "f" works out correctly. Therefore, the REFERENCE_TYPE is
13366 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
13369 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
13370 Return a new TREE_LIST with the various arguments replaced with
13371 equivalent non-dependent expressions. */
13374 build_non_dependent_args (tree args)
13379 new_args = NULL_TREE;
13380 for (a = args; a; a = TREE_CHAIN (a))
13381 new_args = tree_cons (NULL_TREE,
13382 build_non_dependent_expr (TREE_VALUE (a)),
13384 return nreverse (new_args);
13387 #include "gt-cp-pt.h"