1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
31 #include "coretypes.h"
35 #include "pointer-set.h"
38 #include "tree-inline.h"
45 #include "tree-iterator.h"
47 /* The type of functions taking a tree, and some additional data, and
49 typedef int (*tree_fn_t) (tree, void*);
51 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
52 instantiations have been deferred, either because their definitions
53 were not yet available, or because we were putting off doing the work.
54 The TREE_PURPOSE of each entry is either a DECL (for a function or
55 static data member), or a TYPE (for a class) indicating what we are
56 hoping to instantiate. The TREE_VALUE is not used. */
57 static GTY(()) tree pending_templates;
58 static GTY(()) tree last_pending_template;
60 int processing_template_parmlist;
61 static int template_header_count;
63 static GTY(()) tree saved_trees;
64 static GTY(()) varray_type inline_parm_levels;
65 static size_t inline_parm_levels_used;
67 static GTY(()) tree current_tinst_level;
69 static GTY(()) tree saved_access_scope;
71 /* Live only within one (recursive) call to tsubst_expr. We use
72 this to pass the statement expression node from the STMT_EXPR
73 to the EXPR_STMT that is its result. */
74 static tree cur_stmt_expr;
76 /* A map from local variable declarations in the body of the template
77 presently being instantiated to the corresponding instantiated
79 static htab_t local_specializations;
81 #define UNIFY_ALLOW_NONE 0
82 #define UNIFY_ALLOW_MORE_CV_QUAL 1
83 #define UNIFY_ALLOW_LESS_CV_QUAL 2
84 #define UNIFY_ALLOW_DERIVED 4
85 #define UNIFY_ALLOW_INTEGER 8
86 #define UNIFY_ALLOW_OUTER_LEVEL 16
87 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
88 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
89 #define UNIFY_ALLOW_MAX_CORRECTION 128
91 static void push_access_scope (tree);
92 static void pop_access_scope (tree);
93 static int resolve_overloaded_unification (tree, tree, tree, tree,
94 unification_kind_t, int);
95 static int try_one_overload (tree, tree, tree, tree, tree,
96 unification_kind_t, int, bool);
97 static int unify (tree, tree, tree, tree, int);
98 static void add_pending_template (tree);
99 static void reopen_tinst_level (tree);
100 static tree classtype_mangled_name (tree);
101 static char* mangle_class_name_for_template (const char *, tree, tree);
102 static tree tsubst_initializer_list (tree, tree);
103 static tree get_class_bindings (tree, tree, tree);
104 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t, int);
105 static void tsubst_enum (tree, tree, tree);
106 static tree add_to_template_args (tree, tree);
107 static tree add_outermost_template_args (tree, tree);
108 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
109 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
110 static int type_unification_real (tree, tree, tree, tree,
111 int, unification_kind_t, int, int);
112 static void note_template_header (int);
113 static tree convert_nontype_argument_function (tree, tree);
114 static tree convert_nontype_argument (tree, tree);
115 static tree convert_template_argument (tree, tree, tree,
116 tsubst_flags_t, int, tree);
117 static tree get_bindings_overload (tree, tree, tree);
118 static int for_each_template_parm (tree, tree_fn_t, void*,
119 struct pointer_set_t*);
120 static tree build_template_parm_index (int, int, int, tree, tree);
121 static int inline_needs_template_parms (tree);
122 static void push_inline_template_parms_recursive (tree, int);
123 static tree retrieve_local_specialization (tree);
124 static void register_local_specialization (tree, tree);
125 static tree reduce_template_parm_level (tree, tree, int);
126 static int mark_template_parm (tree, void *);
127 static int template_parm_this_level_p (tree, void *);
128 static tree tsubst_friend_function (tree, tree);
129 static tree tsubst_friend_class (tree, tree);
130 static int can_complete_type_without_circularity (tree);
131 static tree get_bindings (tree, tree, tree);
132 static tree get_bindings_real (tree, tree, tree, int, int, int);
133 static int template_decl_level (tree);
134 static int check_cv_quals_for_unify (int, tree, tree);
135 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
136 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
137 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
138 static void regenerate_decl_from_template (tree, tree);
139 static tree most_specialized (tree, tree, tree);
140 static tree most_specialized_class (tree, tree);
141 static int template_class_depth_real (tree, int);
142 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
143 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
144 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
145 static void check_specialization_scope (void);
146 static tree process_partial_specialization (tree);
147 static void set_current_access_from_decl (tree);
148 static void check_default_tmpl_args (tree, tree, int, int);
149 static tree tsubst_call_declarator_parms (tree, tree, tsubst_flags_t, tree);
150 static tree get_template_base (tree, tree, tree, tree);
151 static int verify_class_unification (tree, tree, tree);
152 static tree try_class_unification (tree, tree, tree, tree);
153 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
155 static tree determine_specialization (tree, tree, tree *, int, int);
156 static int template_args_equal (tree, tree);
157 static void tsubst_default_arguments (tree);
158 static tree for_each_template_parm_r (tree *, int *, void *);
159 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
160 static void copy_default_args_to_explicit_spec (tree);
161 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
162 static int eq_local_specializations (const void *, const void *);
163 static bool dependent_type_p_r (tree);
164 static tree tsubst (tree, tree, tsubst_flags_t, tree);
165 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree);
166 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
168 /* Make the current scope suitable for access checking when we are
169 processing T. T can be FUNCTION_DECL for instantiated function
170 template, or VAR_DECL for static member variable (need by
171 instantiate_decl). */
174 push_access_scope (tree t)
176 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
177 || TREE_CODE (t) == VAR_DECL);
179 if (DECL_FRIEND_CONTEXT (t))
180 push_nested_class (DECL_FRIEND_CONTEXT (t));
181 else if (DECL_CLASS_SCOPE_P (t))
182 push_nested_class (DECL_CONTEXT (t));
184 push_to_top_level ();
186 if (TREE_CODE (t) == FUNCTION_DECL)
188 saved_access_scope = tree_cons
189 (NULL_TREE, current_function_decl, saved_access_scope);
190 current_function_decl = t;
194 /* Restore the scope set up by push_access_scope. T is the node we
198 pop_access_scope (tree t)
200 if (TREE_CODE (t) == FUNCTION_DECL)
202 current_function_decl = TREE_VALUE (saved_access_scope);
203 saved_access_scope = TREE_CHAIN (saved_access_scope);
206 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
209 pop_from_top_level ();
212 /* Do any processing required when DECL (a member template
213 declaration) is finished. Returns the TEMPLATE_DECL corresponding
214 to DECL, unless it is a specialization, in which case the DECL
215 itself is returned. */
218 finish_member_template_decl (tree decl)
220 if (decl == error_mark_node)
221 return error_mark_node;
223 gcc_assert (DECL_P (decl));
225 if (TREE_CODE (decl) == TYPE_DECL)
229 type = TREE_TYPE (decl);
230 if (IS_AGGR_TYPE (type)
231 && CLASSTYPE_TEMPLATE_INFO (type)
232 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
234 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
235 check_member_template (tmpl);
240 else if (TREE_CODE (decl) == FIELD_DECL)
241 error ("data member %qD cannot be a member template", decl);
242 else if (DECL_TEMPLATE_INFO (decl))
244 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
246 check_member_template (DECL_TI_TEMPLATE (decl));
247 return DECL_TI_TEMPLATE (decl);
253 error ("invalid member template declaration %qD", decl);
255 return error_mark_node;
258 /* Returns the template nesting level of the indicated class TYPE.
268 A<T>::B<U> has depth two, while A<T> has depth one.
269 Both A<T>::B<int> and A<int>::B<U> have depth one, if
270 COUNT_SPECIALIZATIONS is 0 or if they are instantiations, not
273 This function is guaranteed to return 0 if passed NULL_TREE so
274 that, for example, `template_class_depth (current_class_type)' is
278 template_class_depth_real (tree type, int count_specializations)
283 type && TREE_CODE (type) != NAMESPACE_DECL;
284 type = (TREE_CODE (type) == FUNCTION_DECL)
285 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
287 if (TREE_CODE (type) != FUNCTION_DECL)
289 if (CLASSTYPE_TEMPLATE_INFO (type)
290 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
291 && ((count_specializations
292 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
293 || uses_template_parms (CLASSTYPE_TI_ARGS (type))))
298 if (DECL_TEMPLATE_INFO (type)
299 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
300 && ((count_specializations
301 && DECL_TEMPLATE_SPECIALIZATION (type))
302 || uses_template_parms (DECL_TI_ARGS (type))))
310 /* Returns the template nesting level of the indicated class TYPE.
311 Like template_class_depth_real, but instantiations do not count in
315 template_class_depth (tree type)
317 return template_class_depth_real (type, /*count_specializations=*/0);
320 /* Returns 1 if processing DECL as part of do_pending_inlines
321 needs us to push template parms. */
324 inline_needs_template_parms (tree decl)
326 if (! DECL_TEMPLATE_INFO (decl))
329 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
330 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
333 /* Subroutine of maybe_begin_member_template_processing.
334 Push the template parms in PARMS, starting from LEVELS steps into the
335 chain, and ending at the beginning, since template parms are listed
339 push_inline_template_parms_recursive (tree parmlist, int levels)
341 tree parms = TREE_VALUE (parmlist);
345 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
347 ++processing_template_decl;
348 current_template_parms
349 = tree_cons (size_int (processing_template_decl),
350 parms, current_template_parms);
351 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
353 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
355 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
357 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
358 gcc_assert (DECL_P (parm));
360 switch (TREE_CODE (parm))
369 /* Make a CONST_DECL as is done in process_template_parm.
370 It is ugly that we recreate this here; the original
371 version built in process_template_parm is no longer
373 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
375 DECL_ARTIFICIAL (decl) = 1;
376 TREE_CONSTANT (decl) = 1;
377 TREE_INVARIANT (decl) = 1;
378 TREE_READONLY (decl) = 1;
379 DECL_INITIAL (decl) = DECL_INITIAL (parm);
380 SET_DECL_TEMPLATE_PARM_P (decl);
391 /* Restore the template parameter context for a member template or
392 a friend template defined in a class definition. */
395 maybe_begin_member_template_processing (tree decl)
400 if (inline_needs_template_parms (decl))
402 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
403 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
405 if (DECL_TEMPLATE_SPECIALIZATION (decl))
408 parms = TREE_CHAIN (parms);
411 push_inline_template_parms_recursive (parms, levels);
414 /* Remember how many levels of template parameters we pushed so that
415 we can pop them later. */
416 if (!inline_parm_levels)
417 VARRAY_INT_INIT (inline_parm_levels, 4, "inline_parm_levels");
418 if (inline_parm_levels_used == inline_parm_levels->num_elements)
419 VARRAY_GROW (inline_parm_levels, 2 * inline_parm_levels_used);
420 VARRAY_INT (inline_parm_levels, inline_parm_levels_used) = levels;
421 ++inline_parm_levels_used;
424 /* Undo the effects of begin_member_template_processing. */
427 maybe_end_member_template_processing (void)
431 if (!inline_parm_levels_used)
434 --inline_parm_levels_used;
436 i < VARRAY_INT (inline_parm_levels, inline_parm_levels_used);
439 --processing_template_decl;
440 current_template_parms = TREE_CHAIN (current_template_parms);
445 /* Return a new template argument vector which contains all of ARGS,
446 but has as its innermost set of arguments the EXTRA_ARGS. */
449 add_to_template_args (tree args, tree extra_args)
456 extra_depth = TMPL_ARGS_DEPTH (extra_args);
457 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
459 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
460 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
462 for (j = 1; j <= extra_depth; ++j, ++i)
463 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
468 /* Like add_to_template_args, but only the outermost ARGS are added to
469 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
470 (EXTRA_ARGS) levels are added. This function is used to combine
471 the template arguments from a partial instantiation with the
472 template arguments used to attain the full instantiation from the
473 partial instantiation. */
476 add_outermost_template_args (tree args, tree extra_args)
480 /* If there are more levels of EXTRA_ARGS than there are ARGS,
481 something very fishy is going on. */
482 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
484 /* If *all* the new arguments will be the EXTRA_ARGS, just return
486 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
489 /* For the moment, we make ARGS look like it contains fewer levels. */
490 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
492 new_args = add_to_template_args (args, extra_args);
494 /* Now, we restore ARGS to its full dimensions. */
495 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
500 /* Return the N levels of innermost template arguments from the ARGS. */
503 get_innermost_template_args (tree args, int n)
511 /* If N is 1, just return the innermost set of template arguments. */
513 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
515 /* If we're not removing anything, just return the arguments we were
517 extra_levels = TMPL_ARGS_DEPTH (args) - n;
518 gcc_assert (extra_levels >= 0);
519 if (extra_levels == 0)
522 /* Make a new set of arguments, not containing the outer arguments. */
523 new_args = make_tree_vec (n);
524 for (i = 1; i <= n; ++i)
525 SET_TMPL_ARGS_LEVEL (new_args, i,
526 TMPL_ARGS_LEVEL (args, i + extra_levels));
531 /* We've got a template header coming up; push to a new level for storing
535 begin_template_parm_list (void)
537 /* We use a non-tag-transparent scope here, which causes pushtag to
538 put tags in this scope, rather than in the enclosing class or
539 namespace scope. This is the right thing, since we want
540 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
541 global template class, push_template_decl handles putting the
542 TEMPLATE_DECL into top-level scope. For a nested template class,
545 template <class T> struct S1 {
546 template <class T> struct S2 {};
549 pushtag contains special code to call pushdecl_with_scope on the
550 TEMPLATE_DECL for S2. */
551 begin_scope (sk_template_parms, NULL);
552 ++processing_template_decl;
553 ++processing_template_parmlist;
554 note_template_header (0);
557 /* This routine is called when a specialization is declared. If it is
558 invalid to declare a specialization here, an error is reported. */
561 check_specialization_scope (void)
563 tree scope = current_scope ();
567 An explicit specialization shall be declared in the namespace of
568 which the template is a member, or, for member templates, in the
569 namespace of which the enclosing class or enclosing class
570 template is a member. An explicit specialization of a member
571 function, member class or static data member of a class template
572 shall be declared in the namespace of which the class template
574 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
575 error ("explicit specialization in non-namespace scope %qD", scope);
579 In an explicit specialization declaration for a member of a class
580 template or a member template that appears in namespace scope,
581 the member template and some of its enclosing class templates may
582 remain unspecialized, except that the declaration shall not
583 explicitly specialize a class member template if its enclosing
584 class templates are not explicitly specialized as well. */
585 if (current_template_parms)
586 error ("enclosing class templates are not explicitly specialized");
589 /* We've just seen template <>. */
592 begin_specialization (void)
594 begin_scope (sk_template_spec, NULL);
595 note_template_header (1);
596 check_specialization_scope ();
599 /* Called at then end of processing a declaration preceded by
603 end_specialization (void)
606 reset_specialization ();
609 /* Any template <>'s that we have seen thus far are not referring to a
610 function specialization. */
613 reset_specialization (void)
615 processing_specialization = 0;
616 template_header_count = 0;
619 /* We've just seen a template header. If SPECIALIZATION is nonzero,
620 it was of the form template <>. */
623 note_template_header (int specialization)
625 processing_specialization = specialization;
626 template_header_count++;
629 /* We're beginning an explicit instantiation. */
632 begin_explicit_instantiation (void)
634 gcc_assert (!processing_explicit_instantiation);
635 processing_explicit_instantiation = true;
640 end_explicit_instantiation (void)
642 gcc_assert (processing_explicit_instantiation);
643 processing_explicit_instantiation = false;
646 /* A explicit specialization or partial specialization TMPL is being
647 declared. Check that the namespace in which the specialization is
648 occurring is permissible. Returns false iff it is invalid to
649 specialize TMPL in the current namespace. */
652 check_specialization_namespace (tree tmpl)
654 tree tpl_ns = decl_namespace_context (tmpl);
658 An explicit specialization shall be declared in the namespace of
659 which the template is a member, or, for member templates, in the
660 namespace of which the enclosing class or enclosing class
661 template is a member. An explicit specialization of a member
662 function, member class or static data member of a class template
663 shall be declared in the namespace of which the class template is
665 if (is_associated_namespace (current_namespace, tpl_ns))
666 /* Same or super-using namespace. */
670 pedwarn ("specialization of %qD in different namespace", tmpl);
671 cp_pedwarn_at (" from definition of %q#D", tmpl);
676 /* The TYPE is being declared. If it is a template type, that means it
677 is a partial specialization. Do appropriate error-checking. */
680 maybe_process_partial_specialization (tree type)
682 /* TYPE maybe an ERROR_MARK_NODE. */
683 tree context = TYPE_P (type) ? TYPE_CONTEXT (type) : NULL_TREE;
685 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
687 /* This is for ordinary explicit specialization and partial
688 specialization of a template class such as:
690 template <> class C<int>;
694 template <class T> class C<T*>;
696 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
698 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
699 && !COMPLETE_TYPE_P (type))
701 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
702 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
703 if (processing_template_decl)
704 push_template_decl (TYPE_MAIN_DECL (type));
706 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
707 error ("specialization of %qT after instantiation", type);
709 else if (CLASS_TYPE_P (type)
710 && !CLASSTYPE_USE_TEMPLATE (type)
711 && CLASSTYPE_TEMPLATE_INFO (type)
712 && context && CLASS_TYPE_P (context)
713 && CLASSTYPE_TEMPLATE_INFO (context))
715 /* This is for an explicit specialization of member class
716 template according to [temp.expl.spec/18]:
718 template <> template <class U> class C<int>::D;
720 The context `C<int>' must be an implicit instantiation.
721 Otherwise this is just a member class template declared
724 template <> class C<int> { template <class U> class D; };
725 template <> template <class U> class C<int>::D;
727 In the first case, `C<int>::D' is a specialization of `C<T>::D'
728 while in the second case, `C<int>::D' is a primary template
729 and `C<T>::D' may not exist. */
731 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
732 && !COMPLETE_TYPE_P (type))
736 if (current_namespace
737 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
739 pedwarn ("specializing %q#T in different namespace", type);
740 cp_pedwarn_at (" from definition of %q#D",
741 CLASSTYPE_TI_TEMPLATE (type));
744 /* Check for invalid specialization after instantiation:
746 template <> template <> class C<int>::D<int>;
747 template <> template <class U> class C<int>::D; */
749 for (t = DECL_TEMPLATE_INSTANTIATIONS
750 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
751 t; t = TREE_CHAIN (t))
752 if (TREE_VALUE (t) != type
753 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
754 error ("specialization %qT after instantiation %qT",
755 type, TREE_VALUE (t));
757 /* Mark TYPE as a specialization. And as a result, we only
758 have one level of template argument for the innermost
760 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
761 CLASSTYPE_TI_ARGS (type)
762 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
765 else if (processing_specialization)
766 error ("explicit specialization of non-template %qT", type);
769 /* Returns nonzero if we can optimize the retrieval of specializations
770 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
771 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
774 optimize_specialization_lookup_p (tree tmpl)
776 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
777 && DECL_CLASS_SCOPE_P (tmpl)
778 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
780 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
781 /* The optimized lookup depends on the fact that the
782 template arguments for the member function template apply
783 purely to the containing class, which is not true if the
784 containing class is an explicit or partial
786 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
787 && !DECL_MEMBER_TEMPLATE_P (tmpl)
788 && !DECL_CONV_FN_P (tmpl)
789 /* It is possible to have a template that is not a member
790 template and is not a member of a template class:
792 template <typename T>
793 struct S { friend A::f(); };
795 Here, the friend function is a template, but the context does
796 not have template information. The optimized lookup relies
797 on having ARGS be the template arguments for both the class
798 and the function template. */
799 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
802 /* Retrieve the specialization (in the sense of [temp.spec] - a
803 specialization is either an instantiation or an explicit
804 specialization) of TMPL for the given template ARGS. If there is
805 no such specialization, return NULL_TREE. The ARGS are a vector of
806 arguments, or a vector of vectors of arguments, in the case of
807 templates with more than one level of parameters.
809 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
810 then we search for a partial specialization matching ARGS. This
811 parameter is ignored if TMPL is not a class template. */
814 retrieve_specialization (tree tmpl, tree args,
815 bool class_specializations_p)
817 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
819 /* There should be as many levels of arguments as there are
820 levels of parameters. */
821 gcc_assert (TMPL_ARGS_DEPTH (args)
822 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
824 if (optimize_specialization_lookup_p (tmpl))
827 tree class_specialization;
832 /* The template arguments actually apply to the containing
833 class. Find the class specialization with those
835 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
837 = retrieve_specialization (class_template, args,
838 /*class_specializations_p=*/false);
839 if (!class_specialization)
841 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
842 for the specialization. */
843 idx = class_method_index_for_fn (class_specialization, tmpl);
846 /* Iterate through the methods with the indicated name, looking
847 for the one that has an instance of TMPL. */
848 methods = CLASSTYPE_METHOD_VEC (class_specialization);
849 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
851 tree fn = OVL_CURRENT (fns);
852 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
862 /* Class templates store their instantiations on the
863 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
864 DECL_TEMPLATE_SPECIALIZATIONS list. */
865 if (!class_specializations_p
866 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
867 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
869 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
871 /* Iterate through the list until we find a matching template. */
872 while (*sp != NULL_TREE)
876 if (comp_template_args (TREE_PURPOSE (spec), args))
878 /* Use the move-to-front heuristic to speed up future
882 *sp = TREE_CHAIN (*sp);
883 TREE_CHAIN (spec) = *head;
886 return TREE_VALUE (spec);
888 sp = &TREE_CHAIN (spec);
895 /* Like retrieve_specialization, but for local declarations. */
898 retrieve_local_specialization (tree tmpl)
900 tree spec = htab_find_with_hash (local_specializations, tmpl,
901 htab_hash_pointer (tmpl));
902 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
905 /* Returns nonzero iff DECL is a specialization of TMPL. */
908 is_specialization_of (tree decl, tree tmpl)
912 if (TREE_CODE (decl) == FUNCTION_DECL)
916 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
922 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
924 for (t = TREE_TYPE (decl);
926 t = CLASSTYPE_USE_TEMPLATE (t)
927 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
928 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
935 /* Returns nonzero iff DECL is a specialization of friend declaration
936 FRIEND according to [temp.friend]. */
939 is_specialization_of_friend (tree decl, tree friend)
941 bool need_template = true;
944 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
945 || TREE_CODE (decl) == TYPE_DECL);
947 /* For [temp.friend/6] when FRIEND is an ordinary member function
948 of a template class, we want to check if DECL is a specialization
950 if (TREE_CODE (friend) == FUNCTION_DECL
951 && DECL_TEMPLATE_INFO (friend)
952 && !DECL_USE_TEMPLATE (friend))
954 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
955 friend = DECL_TI_TEMPLATE (friend);
956 need_template = false;
958 else if (TREE_CODE (friend) == TEMPLATE_DECL
959 && !PRIMARY_TEMPLATE_P (friend))
960 need_template = false;
962 /* There is nothing to do if this is not a template friend. */
963 if (TREE_CODE (friend) != TEMPLATE_DECL)
966 if (is_specialization_of (decl, friend))
970 A member of a class template may be declared to be a friend of a
971 non-template class. In this case, the corresponding member of
972 every specialization of the class template is a friend of the
973 class granting friendship.
975 For example, given a template friend declaration
977 template <class T> friend void A<T>::f();
979 the member function below is considered a friend
981 template <> struct A<int> {
985 For this type of template friend, TEMPLATE_DEPTH below will be
986 nonzero. To determine if DECL is a friend of FRIEND, we first
987 check if the enclosing class is a specialization of another. */
989 template_depth = template_class_depth (DECL_CONTEXT (friend));
991 && DECL_CLASS_SCOPE_P (decl)
992 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
993 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
995 /* Next, we check the members themselves. In order to handle
996 a few tricky cases, such as when FRIEND's are
998 template <class T> friend void A<T>::g(T t);
999 template <class T> template <T t> friend void A<T>::h();
1003 void A<int>::g(int);
1004 template <int> void A<int>::h();
1006 we need to figure out ARGS, the template arguments from
1007 the context of DECL. This is required for template substitution
1008 of `T' in the function parameter of `g' and template parameter
1009 of `h' in the above examples. Here ARGS corresponds to `int'. */
1011 tree context = DECL_CONTEXT (decl);
1012 tree args = NULL_TREE;
1013 int current_depth = 0;
1015 while (current_depth < template_depth)
1017 if (CLASSTYPE_TEMPLATE_INFO (context))
1019 if (current_depth == 0)
1020 args = TYPE_TI_ARGS (context);
1022 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1025 context = TYPE_CONTEXT (context);
1028 if (TREE_CODE (decl) == FUNCTION_DECL)
1033 tree friend_args_type;
1034 tree decl_args_type;
1036 /* Make sure that both DECL and FRIEND are templates or
1038 is_template = DECL_TEMPLATE_INFO (decl)
1039 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1040 if (need_template ^ is_template)
1042 else if (is_template)
1044 /* If both are templates, check template parameter list. */
1046 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1048 if (!comp_template_parms
1049 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1053 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1056 decl_type = TREE_TYPE (decl);
1058 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1059 tf_none, NULL_TREE);
1060 if (friend_type == error_mark_node)
1063 /* Check if return types match. */
1064 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1067 /* Check if function parameter types match, ignoring the
1068 `this' parameter. */
1069 friend_args_type = TYPE_ARG_TYPES (friend_type);
1070 decl_args_type = TYPE_ARG_TYPES (decl_type);
1071 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1072 friend_args_type = TREE_CHAIN (friend_args_type);
1073 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1074 decl_args_type = TREE_CHAIN (decl_args_type);
1076 return compparms (decl_args_type, friend_args_type);
1080 /* DECL is a TYPE_DECL */
1082 tree decl_type = TREE_TYPE (decl);
1084 /* Make sure that both DECL and FRIEND are templates or
1087 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1088 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1090 if (need_template ^ is_template)
1092 else if (is_template)
1095 /* If both are templates, check the name of the two
1096 TEMPLATE_DECL's first because is_friend didn't. */
1097 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1098 != DECL_NAME (friend))
1101 /* Now check template parameter list. */
1103 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1105 return comp_template_parms
1106 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1110 return (DECL_NAME (decl)
1111 == DECL_NAME (friend));
1117 /* Register the specialization SPEC as a specialization of TMPL with
1118 the indicated ARGS. Returns SPEC, or an equivalent prior
1119 declaration, if available. */
1122 register_specialization (tree spec, tree tmpl, tree args)
1126 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1128 if (TREE_CODE (spec) == FUNCTION_DECL
1129 && uses_template_parms (DECL_TI_ARGS (spec)))
1130 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1131 register it; we want the corresponding TEMPLATE_DECL instead.
1132 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1133 the more obvious `uses_template_parms (spec)' to avoid problems
1134 with default function arguments. In particular, given
1135 something like this:
1137 template <class T> void f(T t1, T t = T())
1139 the default argument expression is not substituted for in an
1140 instantiation unless and until it is actually needed. */
1143 /* There should be as many levels of arguments as there are
1144 levels of parameters. */
1145 gcc_assert (TMPL_ARGS_DEPTH (args)
1146 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
1148 fn = retrieve_specialization (tmpl, args,
1149 /*class_specializations_p=*/false);
1150 /* We can sometimes try to re-register a specialization that we've
1151 already got. In particular, regenerate_decl_from_template calls
1152 duplicate_decls which will update the specialization list. But,
1153 we'll still get called again here anyhow. It's more convenient
1154 to simply allow this than to try to prevent it. */
1157 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1159 if (DECL_TEMPLATE_INSTANTIATION (fn))
1162 || DECL_EXPLICIT_INSTANTIATION (fn))
1164 error ("specialization of %qD after instantiation",
1170 /* This situation should occur only if the first
1171 specialization is an implicit instantiation, the
1172 second is an explicit specialization, and the
1173 implicit instantiation has not yet been used. That
1174 situation can occur if we have implicitly
1175 instantiated a member function and then specialized
1178 We can also wind up here if a friend declaration that
1179 looked like an instantiation turns out to be a
1182 template <class T> void foo(T);
1183 class S { friend void foo<>(int) };
1184 template <> void foo(int);
1186 We transform the existing DECL in place so that any
1187 pointers to it become pointers to the updated
1190 If there was a definition for the template, but not
1191 for the specialization, we want this to look as if
1192 there were no definition, and vice versa. */
1193 DECL_INITIAL (fn) = NULL_TREE;
1194 duplicate_decls (spec, fn);
1199 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1201 if (!duplicate_decls (spec, fn) && DECL_INITIAL (spec))
1202 /* Dup decl failed, but this is a new definition. Set the
1203 line number so any errors match this new
1205 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1211 /* A specialization must be declared in the same namespace as the
1212 template it is specializing. */
1213 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1214 && !check_specialization_namespace (tmpl))
1215 DECL_CONTEXT (spec) = decl_namespace_context (tmpl);
1217 if (!optimize_specialization_lookup_p (tmpl))
1218 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1219 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1224 /* Unregister the specialization SPEC as a specialization of TMPL.
1225 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1226 if the SPEC was listed as a specialization of TMPL. */
1229 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1233 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1235 s = &TREE_CHAIN (*s))
1236 if (TREE_VALUE (*s) == spec)
1239 *s = TREE_CHAIN (*s);
1241 TREE_VALUE (*s) = new_spec;
1248 /* Compare an entry in the local specializations hash table P1 (which
1249 is really a pointer to a TREE_LIST) with P2 (which is really a
1253 eq_local_specializations (const void *p1, const void *p2)
1255 return TREE_VALUE ((tree) p1) == (tree) p2;
1258 /* Hash P1, an entry in the local specializations table. */
1261 hash_local_specialization (const void* p1)
1263 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1266 /* Like register_specialization, but for local declarations. We are
1267 registering SPEC, an instantiation of TMPL. */
1270 register_local_specialization (tree spec, tree tmpl)
1274 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1275 htab_hash_pointer (tmpl), INSERT);
1276 *slot = build_tree_list (spec, tmpl);
1279 /* Print the list of candidate FNS in an error message. */
1282 print_candidates (tree fns)
1286 const char *str = "candidates are:";
1288 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1292 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1293 cp_error_at ("%s %+#D", str, OVL_CURRENT (f));
1298 /* Returns the template (one of the functions given by TEMPLATE_ID)
1299 which can be specialized to match the indicated DECL with the
1300 explicit template args given in TEMPLATE_ID. The DECL may be
1301 NULL_TREE if none is available. In that case, the functions in
1302 TEMPLATE_ID are non-members.
1304 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1305 specialization of a member template.
1307 The TEMPLATE_COUNT is the number of references to qualifying
1308 template classes that appeared in the name of the function. See
1309 check_explicit_specialization for a more accurate description.
1311 The template args (those explicitly specified and those deduced)
1312 are output in a newly created vector *TARGS_OUT.
1314 If it is impossible to determine the result, an error message is
1315 issued. The error_mark_node is returned to indicate failure. */
1318 determine_specialization (tree template_id,
1321 int need_member_template,
1326 tree explicit_targs;
1327 tree candidates = NULL_TREE;
1328 tree templates = NULL_TREE;
1330 struct cp_binding_level *b;
1332 *targs_out = NULL_TREE;
1334 if (template_id == error_mark_node)
1335 return error_mark_node;
1337 fns = TREE_OPERAND (template_id, 0);
1338 explicit_targs = TREE_OPERAND (template_id, 1);
1340 if (fns == error_mark_node)
1341 return error_mark_node;
1343 /* Check for baselinks. */
1344 if (BASELINK_P (fns))
1345 fns = BASELINK_FUNCTIONS (fns);
1347 if (!is_overloaded_fn (fns))
1349 error ("%qD is not a function template", fns);
1350 return error_mark_node;
1353 /* Count the number of template headers specified for this
1356 for (b = current_binding_level;
1357 b->kind == sk_template_parms;
1361 for (; fns; fns = OVL_NEXT (fns))
1363 tree fn = OVL_CURRENT (fns);
1365 if (TREE_CODE (fn) == TEMPLATE_DECL)
1367 tree decl_arg_types;
1370 /* DECL might be a specialization of FN. */
1372 /* Adjust the type of DECL in case FN is a static member. */
1373 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1374 if (DECL_STATIC_FUNCTION_P (fn)
1375 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1376 decl_arg_types = TREE_CHAIN (decl_arg_types);
1378 /* Check that the number of function parameters matches.
1380 template <class T> void f(int i = 0);
1381 template <> void f<int>();
1382 The specialization f<int> is invalid but is not caught
1383 by get_bindings below. */
1385 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1386 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1389 /* For a non-static member function, we need to make sure that
1390 the const qualification is the same. This can be done by
1391 checking the 'this' in the argument list. */
1392 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1393 && !same_type_p (TREE_VALUE (fn_arg_types),
1394 TREE_VALUE (decl_arg_types)))
1397 /* In case of explicit specialization, we need to check if
1398 the number of template headers appearing in the specialization
1399 is correct. This is usually done in check_explicit_specialization,
1400 but the check done there cannot be exhaustive when specializing
1401 member functions. Consider the following code:
1403 template <> void A<int>::f(int);
1404 template <> template <> void A<int>::f(int);
1406 Assuming that A<int> is not itself an explicit specialization
1407 already, the first line specializes "f" which is a non-template
1408 member function, whilst the second line specializes "f" which
1409 is a template member function. So both lines are syntactically
1410 correct, and check_explicit_specialization does not reject
1413 Here, we can do better, as we are matching the specialization
1414 against the declarations. We count the number of template
1415 headers, and we check if they match TEMPLATE_COUNT + 1
1416 (TEMPLATE_COUNT is the number of qualifying template classes,
1417 plus there must be another header for the member template
1420 Notice that if header_count is zero, this is not a
1421 specialization but rather a template instantiation, so there
1422 is no check we can perform here. */
1423 if (header_count && header_count != template_count + 1)
1426 /* Check that the number of template arguments at the
1427 innermost level for DECL is the same as for FN. */
1428 if (current_binding_level->kind == sk_template_parms
1429 && !current_binding_level->explicit_spec_p
1430 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1431 != TREE_VEC_LENGTH (TREE_VALUE (current_template_parms))))
1434 /* See whether this function might be a specialization of this
1436 targs = get_bindings (fn, decl, explicit_targs);
1439 /* We cannot deduce template arguments that when used to
1440 specialize TMPL will produce DECL. */
1443 /* Save this template, and the arguments deduced. */
1444 templates = tree_cons (targs, fn, templates);
1446 else if (need_member_template)
1447 /* FN is an ordinary member function, and we need a
1448 specialization of a member template. */
1450 else if (TREE_CODE (fn) != FUNCTION_DECL)
1451 /* We can get IDENTIFIER_NODEs here in certain erroneous
1454 else if (!DECL_FUNCTION_MEMBER_P (fn))
1455 /* This is just an ordinary non-member function. Nothing can
1456 be a specialization of that. */
1458 else if (DECL_ARTIFICIAL (fn))
1459 /* Cannot specialize functions that are created implicitly. */
1463 tree decl_arg_types;
1465 /* This is an ordinary member function. However, since
1466 we're here, we can assume it's enclosing class is a
1467 template class. For example,
1469 template <typename T> struct S { void f(); };
1470 template <> void S<int>::f() {}
1472 Here, S<int>::f is a non-template, but S<int> is a
1473 template class. If FN has the same type as DECL, we
1474 might be in business. */
1476 if (!DECL_TEMPLATE_INFO (fn))
1477 /* Its enclosing class is an explicit specialization
1478 of a template class. This is not a candidate. */
1481 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1482 TREE_TYPE (TREE_TYPE (fn))))
1483 /* The return types differ. */
1486 /* Adjust the type of DECL in case FN is a static member. */
1487 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1488 if (DECL_STATIC_FUNCTION_P (fn)
1489 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1490 decl_arg_types = TREE_CHAIN (decl_arg_types);
1492 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1495 candidates = tree_cons (NULL_TREE, fn, candidates);
1499 if (templates && TREE_CHAIN (templates))
1505 It is possible for a specialization with a given function
1506 signature to be instantiated from more than one function
1507 template. In such cases, explicit specification of the
1508 template arguments must be used to uniquely identify the
1509 function template specialization being specialized.
1511 Note that here, there's no suggestion that we're supposed to
1512 determine which of the candidate templates is most
1513 specialized. However, we, also have:
1517 Partial ordering of overloaded function template
1518 declarations is used in the following contexts to select
1519 the function template to which a function template
1520 specialization refers:
1522 -- when an explicit specialization refers to a function
1525 So, we do use the partial ordering rules, at least for now.
1526 This extension can only serve to make invalid programs valid,
1527 so it's safe. And, there is strong anecdotal evidence that
1528 the committee intended the partial ordering rules to apply;
1529 the EDG front-end has that behavior, and John Spicer claims
1530 that the committee simply forgot to delete the wording in
1531 [temp.expl.spec]. */
1532 tree tmpl = most_specialized (templates, decl, explicit_targs);
1533 if (tmpl && tmpl != error_mark_node)
1535 targs = get_bindings (tmpl, decl, explicit_targs);
1536 templates = tree_cons (targs, tmpl, NULL_TREE);
1540 if (templates == NULL_TREE && candidates == NULL_TREE)
1542 cp_error_at ("template-id %qD for %q+D does not match any template "
1545 return error_mark_node;
1547 else if ((templates && TREE_CHAIN (templates))
1548 || (candidates && TREE_CHAIN (candidates))
1549 || (templates && candidates))
1551 cp_error_at ("ambiguous template specialization %qD for %q+D",
1553 chainon (candidates, templates);
1554 print_candidates (candidates);
1555 return error_mark_node;
1558 /* We have one, and exactly one, match. */
1561 /* It was a specialization of an ordinary member function in a
1563 *targs_out = copy_node (DECL_TI_ARGS (TREE_VALUE (candidates)));
1564 return DECL_TI_TEMPLATE (TREE_VALUE (candidates));
1567 /* It was a specialization of a template. */
1568 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1569 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1571 *targs_out = copy_node (targs);
1572 SET_TMPL_ARGS_LEVEL (*targs_out,
1573 TMPL_ARGS_DEPTH (*targs_out),
1574 TREE_PURPOSE (templates));
1577 *targs_out = TREE_PURPOSE (templates);
1578 return TREE_VALUE (templates);
1581 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1582 but with the default argument values filled in from those in the
1586 copy_default_args_to_explicit_spec_1 (tree spec_types,
1589 tree new_spec_types;
1594 if (spec_types == void_list_node)
1595 return void_list_node;
1597 /* Substitute into the rest of the list. */
1599 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1600 TREE_CHAIN (tmpl_types));
1602 /* Add the default argument for this parameter. */
1603 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1604 TREE_VALUE (spec_types),
1608 /* DECL is an explicit specialization. Replicate default arguments
1609 from the template it specializes. (That way, code like:
1611 template <class T> void f(T = 3);
1612 template <> void f(double);
1615 works, as required.) An alternative approach would be to look up
1616 the correct default arguments at the call-site, but this approach
1617 is consistent with how implicit instantiations are handled. */
1620 copy_default_args_to_explicit_spec (tree decl)
1625 tree new_spec_types;
1629 tree object_type = NULL_TREE;
1630 tree in_charge = NULL_TREE;
1631 tree vtt = NULL_TREE;
1633 /* See if there's anything we need to do. */
1634 tmpl = DECL_TI_TEMPLATE (decl);
1635 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1636 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1637 if (TREE_PURPOSE (t))
1642 old_type = TREE_TYPE (decl);
1643 spec_types = TYPE_ARG_TYPES (old_type);
1645 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1647 /* Remove the this pointer, but remember the object's type for
1649 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1650 spec_types = TREE_CHAIN (spec_types);
1651 tmpl_types = TREE_CHAIN (tmpl_types);
1653 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1655 /* DECL may contain more parameters than TMPL due to the extra
1656 in-charge parameter in constructors and destructors. */
1657 in_charge = spec_types;
1658 spec_types = TREE_CHAIN (spec_types);
1660 if (DECL_HAS_VTT_PARM_P (decl))
1663 spec_types = TREE_CHAIN (spec_types);
1667 /* Compute the merged default arguments. */
1669 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1671 /* Compute the new FUNCTION_TYPE. */
1675 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1680 /* Put the in-charge parameter back. */
1681 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1682 TREE_VALUE (in_charge),
1685 new_type = build_method_type_directly (object_type,
1686 TREE_TYPE (old_type),
1690 new_type = build_function_type (TREE_TYPE (old_type),
1692 new_type = cp_build_type_attribute_variant (new_type,
1693 TYPE_ATTRIBUTES (old_type));
1694 new_type = build_exception_variant (new_type,
1695 TYPE_RAISES_EXCEPTIONS (old_type));
1696 TREE_TYPE (decl) = new_type;
1699 /* Check to see if the function just declared, as indicated in
1700 DECLARATOR, and in DECL, is a specialization of a function
1701 template. We may also discover that the declaration is an explicit
1702 instantiation at this point.
1704 Returns DECL, or an equivalent declaration that should be used
1705 instead if all goes well. Issues an error message if something is
1706 amiss. Returns error_mark_node if the error is not easily
1709 FLAGS is a bitmask consisting of the following flags:
1711 2: The function has a definition.
1712 4: The function is a friend.
1714 The TEMPLATE_COUNT is the number of references to qualifying
1715 template classes that appeared in the name of the function. For
1718 template <class T> struct S { void f(); };
1721 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1722 classes are not counted in the TEMPLATE_COUNT, so that in
1724 template <class T> struct S {};
1725 template <> struct S<int> { void f(); }
1726 template <> void S<int>::f();
1728 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1729 invalid; there should be no template <>.)
1731 If the function is a specialization, it is marked as such via
1732 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1733 is set up correctly, and it is added to the list of specializations
1734 for that template. */
1737 check_explicit_specialization (tree declarator,
1742 int have_def = flags & 2;
1743 int is_friend = flags & 4;
1744 int specialization = 0;
1745 int explicit_instantiation = 0;
1746 int member_specialization = 0;
1747 tree ctype = DECL_CLASS_CONTEXT (decl);
1748 tree dname = DECL_NAME (decl);
1753 if (!processing_specialization)
1756 tsk = tsk_excessive_parms;
1759 tsk = current_tmpl_spec_kind (template_count);
1764 if (processing_specialization)
1767 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1769 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1772 /* This could be something like:
1774 template <class T> void f(T);
1775 class S { friend void f<>(int); } */
1779 /* This case handles bogus declarations like template <>
1780 template <class T> void f<int>(); */
1782 error ("template-id %qD in declaration of primary template",
1789 case tsk_invalid_member_spec:
1790 /* The error has already been reported in
1791 check_specialization_scope. */
1792 return error_mark_node;
1794 case tsk_invalid_expl_inst:
1795 error ("template parameter list used in explicit instantiation");
1801 error ("definition provided for explicit instantiation");
1803 explicit_instantiation = 1;
1806 case tsk_excessive_parms:
1807 case tsk_insufficient_parms:
1808 if (tsk == tsk_excessive_parms)
1809 error ("too many template parameter lists in declaration of %qD",
1811 else if (template_header_count)
1812 error("too few template parameter lists in declaration of %qD", decl);
1814 error("explicit specialization of %qD must be introduced by "
1815 "%<template <>%>", decl);
1819 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1821 member_specialization = 1;
1827 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1829 /* This case handles bogus declarations like template <>
1830 template <class T> void f<int>(); */
1832 if (uses_template_parms (declarator))
1833 error ("function template partial specialization %qD "
1834 "is not allowed", declarator);
1836 error ("template-id %qD in declaration of primary template",
1841 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1842 /* This is a specialization of a member template, without
1843 specialization the containing class. Something like:
1845 template <class T> struct S {
1846 template <class U> void f (U);
1848 template <> template <class U> void S<int>::f(U) {}
1850 That's a specialization -- but of the entire template. */
1858 if (specialization || member_specialization)
1860 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1861 for (; t; t = TREE_CHAIN (t))
1862 if (TREE_PURPOSE (t))
1865 ("default argument specified in explicit specialization");
1868 if (current_lang_name == lang_name_c)
1869 error ("template specialization with C linkage");
1872 if (specialization || member_specialization || explicit_instantiation)
1874 tree tmpl = NULL_TREE;
1875 tree targs = NULL_TREE;
1877 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1878 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1882 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
1887 /* If there is no class context, the explicit instantiation
1888 must be at namespace scope. */
1889 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
1891 /* Find the namespace binding, using the declaration
1893 fns = namespace_binding (dname, CP_DECL_CONTEXT (decl));
1894 if (!fns || !is_overloaded_fn (fns))
1896 error ("%qD is not a template function", dname);
1897 fns = error_mark_node;
1901 declarator = lookup_template_function (fns, NULL_TREE);
1904 if (declarator == error_mark_node)
1905 return error_mark_node;
1907 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
1909 if (!explicit_instantiation)
1910 /* A specialization in class scope. This is invalid,
1911 but the error will already have been flagged by
1912 check_specialization_scope. */
1913 return error_mark_node;
1916 /* It's not valid to write an explicit instantiation in
1919 class C { template void f(); }
1921 This case is caught by the parser. However, on
1924 template class C { void f(); };
1926 (which is invalid) we can get here. The error will be
1933 else if (ctype != NULL_TREE
1934 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
1937 /* Find the list of functions in ctype that have the same
1938 name as the declared function. */
1939 tree name = TREE_OPERAND (declarator, 0);
1940 tree fns = NULL_TREE;
1943 if (constructor_name_p (name, ctype))
1945 int is_constructor = DECL_CONSTRUCTOR_P (decl);
1947 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
1948 : !CLASSTYPE_DESTRUCTORS (ctype))
1950 /* From [temp.expl.spec]:
1952 If such an explicit specialization for the member
1953 of a class template names an implicitly-declared
1954 special member function (clause _special_), the
1955 program is ill-formed.
1957 Similar language is found in [temp.explicit]. */
1958 error ("specialization of implicitly-declared special member function");
1959 return error_mark_node;
1962 name = is_constructor ? ctor_identifier : dtor_identifier;
1965 if (!DECL_CONV_FN_P (decl))
1967 idx = lookup_fnfields_1 (ctype, name);
1969 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
1976 /* For a type-conversion operator, we cannot do a
1977 name-based lookup. We might be looking for `operator
1978 int' which will be a specialization of `operator T'.
1979 So, we find *all* the conversion operators, and then
1980 select from them. */
1983 methods = CLASSTYPE_METHOD_VEC (ctype);
1985 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
1986 VEC_iterate (tree, methods, idx, ovl);
1989 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
1990 /* There are no more conversion functions. */
1993 /* Glue all these conversion functions together
1994 with those we already have. */
1995 for (; ovl; ovl = OVL_NEXT (ovl))
1996 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2000 if (fns == NULL_TREE)
2002 error ("no member function %qD declared in %qT", name, ctype);
2003 return error_mark_node;
2006 TREE_OPERAND (declarator, 0) = fns;
2009 /* Figure out what exactly is being specialized at this point.
2010 Note that for an explicit instantiation, even one for a
2011 member function, we cannot tell apriori whether the
2012 instantiation is for a member template, or just a member
2013 function of a template class. Even if a member template is
2014 being instantiated, the member template arguments may be
2015 elided if they can be deduced from the rest of the
2017 tmpl = determine_specialization (declarator, decl,
2019 member_specialization,
2022 if (!tmpl || tmpl == error_mark_node)
2023 /* We couldn't figure out what this declaration was
2025 return error_mark_node;
2028 tree gen_tmpl = most_general_template (tmpl);
2030 if (explicit_instantiation)
2032 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2033 is done by do_decl_instantiation later. */
2035 int arg_depth = TMPL_ARGS_DEPTH (targs);
2036 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2038 if (arg_depth > parm_depth)
2040 /* If TMPL is not the most general template (for
2041 example, if TMPL is a friend template that is
2042 injected into namespace scope), then there will
2043 be too many levels of TARGS. Remove some of them
2048 new_targs = make_tree_vec (parm_depth);
2049 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2050 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2051 = TREE_VEC_ELT (targs, i);
2055 return instantiate_template (tmpl, targs, tf_error);
2058 /* If we thought that the DECL was a member function, but it
2059 turns out to be specializing a static member function,
2060 make DECL a static member function as well. */
2061 if (DECL_STATIC_FUNCTION_P (tmpl)
2062 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2063 revert_static_member_fn (decl);
2065 /* If this is a specialization of a member template of a
2066 template class. In we want to return the TEMPLATE_DECL,
2067 not the specialization of it. */
2068 if (tsk == tsk_template)
2070 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2071 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2074 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2075 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2076 = DECL_SOURCE_LOCATION (decl);
2077 /* We want to use the argument list specified in the
2078 definition, not in the original declaration. */
2079 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2080 = DECL_ARGUMENTS (decl);
2085 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2086 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2088 /* Inherit default function arguments from the template
2089 DECL is specializing. */
2090 copy_default_args_to_explicit_spec (decl);
2092 /* This specialization has the same protection as the
2093 template it specializes. */
2094 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2095 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2097 if (is_friend && !have_def)
2098 /* This is not really a declaration of a specialization.
2099 It's just the name of an instantiation. But, it's not
2100 a request for an instantiation, either. */
2101 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2102 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2103 /* This is indeed a specialization. In case of constructors
2104 and destructors, we need in-charge and not-in-charge
2105 versions in V3 ABI. */
2106 clone_function_decl (decl, /*update_method_vec_p=*/0);
2108 /* Register this specialization so that we can find it
2110 decl = register_specialization (decl, gen_tmpl, targs);
2117 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2118 parameters. These are represented in the same format used for
2119 DECL_TEMPLATE_PARMS. */
2122 comp_template_parms (tree parms1, tree parms2)
2127 if (parms1 == parms2)
2130 for (p1 = parms1, p2 = parms2;
2131 p1 != NULL_TREE && p2 != NULL_TREE;
2132 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2134 tree t1 = TREE_VALUE (p1);
2135 tree t2 = TREE_VALUE (p2);
2138 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2139 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2141 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2144 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2146 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2147 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2149 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2152 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM)
2154 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2159 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2160 /* One set of parameters has more parameters lists than the
2167 /* Complain if DECL shadows a template parameter.
2169 [temp.local]: A template-parameter shall not be redeclared within its
2170 scope (including nested scopes). */
2173 check_template_shadow (tree decl)
2177 /* If we're not in a template, we can't possibly shadow a template
2179 if (!current_template_parms)
2182 /* Figure out what we're shadowing. */
2183 if (TREE_CODE (decl) == OVERLOAD)
2184 decl = OVL_CURRENT (decl);
2185 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2187 /* If there's no previous binding for this name, we're not shadowing
2188 anything, let alone a template parameter. */
2192 /* If we're not shadowing a template parameter, we're done. Note
2193 that OLDDECL might be an OVERLOAD (or perhaps even an
2194 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2196 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2199 /* We check for decl != olddecl to avoid bogus errors for using a
2200 name inside a class. We check TPFI to avoid duplicate errors for
2201 inline member templates. */
2203 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2206 cp_error_at ("declaration of %q#D", decl);
2207 cp_error_at (" shadows template parm %q#D", olddecl);
2210 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2211 ORIG_LEVEL, DECL, and TYPE. */
2214 build_template_parm_index (int index,
2220 tree t = make_node (TEMPLATE_PARM_INDEX);
2221 TEMPLATE_PARM_IDX (t) = index;
2222 TEMPLATE_PARM_LEVEL (t) = level;
2223 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2224 TEMPLATE_PARM_DECL (t) = decl;
2225 TREE_TYPE (t) = type;
2226 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2227 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2228 TREE_READONLY (t) = TREE_READONLY (decl);
2233 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2234 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2235 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2236 new one is created. */
2239 reduce_template_parm_level (tree index, tree type, int levels)
2241 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2242 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2243 != TEMPLATE_PARM_LEVEL (index) - levels))
2245 tree orig_decl = TEMPLATE_PARM_DECL (index);
2248 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2249 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2250 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2251 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2252 DECL_ARTIFICIAL (decl) = 1;
2253 SET_DECL_TEMPLATE_PARM_P (decl);
2255 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2256 TEMPLATE_PARM_LEVEL (index) - levels,
2257 TEMPLATE_PARM_ORIG_LEVEL (index),
2259 TEMPLATE_PARM_DESCENDANTS (index) = t;
2261 /* Template template parameters need this. */
2262 DECL_TEMPLATE_PARMS (decl)
2263 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2266 return TEMPLATE_PARM_DESCENDANTS (index);
2269 /* Process information from new template parameter NEXT and append it to the
2270 LIST being built. This new parameter is a non-type parameter iff
2271 IS_NON_TYPE is true. */
2274 process_template_parm (tree list, tree next, bool is_non_type)
2282 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2283 defval = TREE_PURPOSE (parm);
2287 tree p = TREE_VALUE (tree_last (list));
2289 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2290 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2292 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2300 parm = TREE_VALUE (parm);
2302 SET_DECL_TEMPLATE_PARM_P (parm);
2306 The top-level cv-qualifiers on the template-parameter are
2307 ignored when determining its type. */
2308 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2310 /* A template parameter is not modifiable. */
2311 TREE_CONSTANT (parm) = 1;
2312 TREE_INVARIANT (parm) = 1;
2313 TREE_READONLY (parm) = 1;
2314 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2315 TREE_TYPE (parm) = void_type_node;
2316 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2317 TREE_CONSTANT (decl) = 1;
2318 TREE_INVARIANT (decl) = 1;
2319 TREE_READONLY (decl) = 1;
2320 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2321 = build_template_parm_index (idx, processing_template_decl,
2322 processing_template_decl,
2323 decl, TREE_TYPE (parm));
2328 parm = TREE_VALUE (TREE_VALUE (parm));
2330 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2332 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2333 /* This is for distinguishing between real templates and template
2334 template parameters */
2335 TREE_TYPE (parm) = t;
2336 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2341 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2342 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2343 decl = build_decl (TYPE_DECL, parm, t);
2346 TYPE_NAME (t) = decl;
2347 TYPE_STUB_DECL (t) = decl;
2349 TEMPLATE_TYPE_PARM_INDEX (t)
2350 = build_template_parm_index (idx, processing_template_decl,
2351 processing_template_decl,
2352 decl, TREE_TYPE (parm));
2354 DECL_ARTIFICIAL (decl) = 1;
2355 SET_DECL_TEMPLATE_PARM_P (decl);
2357 parm = build_tree_list (defval, parm);
2358 return chainon (list, parm);
2361 /* The end of a template parameter list has been reached. Process the
2362 tree list into a parameter vector, converting each parameter into a more
2363 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
2367 end_template_parm_list (tree parms)
2371 tree saved_parmlist = make_tree_vec (list_length (parms));
2373 current_template_parms
2374 = tree_cons (size_int (processing_template_decl),
2375 saved_parmlist, current_template_parms);
2377 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
2379 next = TREE_CHAIN (parm);
2380 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
2381 TREE_CHAIN (parm) = NULL_TREE;
2384 --processing_template_parmlist;
2386 return saved_parmlist;
2389 /* end_template_decl is called after a template declaration is seen. */
2392 end_template_decl (void)
2394 reset_specialization ();
2396 if (! processing_template_decl)
2399 /* This matches the pushlevel in begin_template_parm_list. */
2402 --processing_template_decl;
2403 current_template_parms = TREE_CHAIN (current_template_parms);
2406 /* Given a template argument vector containing the template PARMS.
2407 The innermost PARMS are given first. */
2410 current_template_args (void)
2413 tree args = NULL_TREE;
2414 int length = TMPL_PARMS_DEPTH (current_template_parms);
2417 /* If there is only one level of template parameters, we do not
2418 create a TREE_VEC of TREE_VECs. Instead, we return a single
2419 TREE_VEC containing the arguments. */
2421 args = make_tree_vec (length);
2423 for (header = current_template_parms; header; header = TREE_CHAIN (header))
2425 tree a = copy_node (TREE_VALUE (header));
2428 TREE_TYPE (a) = NULL_TREE;
2429 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
2431 tree t = TREE_VEC_ELT (a, i);
2433 /* T will be a list if we are called from within a
2434 begin/end_template_parm_list pair, but a vector directly
2435 if within a begin/end_member_template_processing pair. */
2436 if (TREE_CODE (t) == TREE_LIST)
2440 if (TREE_CODE (t) == TYPE_DECL
2441 || TREE_CODE (t) == TEMPLATE_DECL)
2444 t = DECL_INITIAL (t);
2445 TREE_VEC_ELT (a, i) = t;
2450 TREE_VEC_ELT (args, --l) = a;
2458 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
2459 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
2460 a member template. Used by push_template_decl below. */
2463 build_template_decl (tree decl, tree parms, bool member_template_p)
2465 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
2466 DECL_TEMPLATE_PARMS (tmpl) = parms;
2467 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
2468 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
2469 if (DECL_LANG_SPECIFIC (decl))
2471 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
2472 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
2473 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
2474 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
2475 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
2476 if (DECL_OVERLOADED_OPERATOR_P (decl))
2477 SET_OVERLOADED_OPERATOR_CODE (tmpl,
2478 DECL_OVERLOADED_OPERATOR_P (decl));
2484 struct template_parm_data
2486 /* The level of the template parameters we are currently
2490 /* The index of the specialization argument we are currently
2494 /* An array whose size is the number of template parameters. The
2495 elements are nonzero if the parameter has been used in any one
2496 of the arguments processed so far. */
2499 /* An array whose size is the number of template arguments. The
2500 elements are nonzero if the argument makes use of template
2501 parameters of this level. */
2502 int* arg_uses_template_parms;
2505 /* Subroutine of push_template_decl used to see if each template
2506 parameter in a partial specialization is used in the explicit
2507 argument list. If T is of the LEVEL given in DATA (which is
2508 treated as a template_parm_data*), then DATA->PARMS is marked
2512 mark_template_parm (tree t, void* data)
2516 struct template_parm_data* tpd = (struct template_parm_data*) data;
2518 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2520 level = TEMPLATE_PARM_LEVEL (t);
2521 idx = TEMPLATE_PARM_IDX (t);
2525 level = TEMPLATE_TYPE_LEVEL (t);
2526 idx = TEMPLATE_TYPE_IDX (t);
2529 if (level == tpd->level)
2531 tpd->parms[idx] = 1;
2532 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
2535 /* Return zero so that for_each_template_parm will continue the
2536 traversal of the tree; we want to mark *every* template parm. */
2540 /* Process the partial specialization DECL. */
2543 process_partial_specialization (tree decl)
2545 tree type = TREE_TYPE (decl);
2546 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
2547 tree specargs = CLASSTYPE_TI_ARGS (type);
2548 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
2549 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
2550 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
2551 int nargs = TREE_VEC_LENGTH (inner_args);
2552 int ntparms = TREE_VEC_LENGTH (inner_parms);
2554 int did_error_intro = 0;
2555 struct template_parm_data tpd;
2556 struct template_parm_data tpd2;
2558 /* We check that each of the template parameters given in the
2559 partial specialization is used in the argument list to the
2560 specialization. For example:
2562 template <class T> struct S;
2563 template <class T> struct S<T*>;
2565 The second declaration is OK because `T*' uses the template
2566 parameter T, whereas
2568 template <class T> struct S<int>;
2570 is no good. Even trickier is:
2581 The S2<T> declaration is actually invalid; it is a
2582 full-specialization. Of course,
2585 struct S2<T (*)(U)>;
2587 or some such would have been OK. */
2588 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
2589 tpd.parms = alloca (sizeof (int) * ntparms);
2590 memset (tpd.parms, 0, sizeof (int) * ntparms);
2592 tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
2593 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
2594 for (i = 0; i < nargs; ++i)
2596 tpd.current_arg = i;
2597 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
2598 &mark_template_parm,
2602 for (i = 0; i < ntparms; ++i)
2603 if (tpd.parms[i] == 0)
2605 /* One of the template parms was not used in the
2607 if (!did_error_intro)
2609 error ("template parameters not used in partial specialization:");
2610 did_error_intro = 1;
2613 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
2616 /* [temp.class.spec]
2618 The argument list of the specialization shall not be identical to
2619 the implicit argument list of the primary template. */
2620 if (comp_template_args
2622 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
2624 error ("partial specialization %qT does not specialize any template arguments", type);
2626 /* [temp.class.spec]
2628 A partially specialized non-type argument expression shall not
2629 involve template parameters of the partial specialization except
2630 when the argument expression is a simple identifier.
2632 The type of a template parameter corresponding to a specialized
2633 non-type argument shall not be dependent on a parameter of the
2635 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
2637 for (i = 0; i < nargs; ++i)
2639 tree arg = TREE_VEC_ELT (inner_args, i);
2640 if (/* These first two lines are the `non-type' bit. */
2642 && TREE_CODE (arg) != TEMPLATE_DECL
2643 /* This next line is the `argument expression is not just a
2644 simple identifier' condition and also the `specialized
2645 non-type argument' bit. */
2646 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
2648 if (tpd.arg_uses_template_parms[i])
2649 error ("template argument %qE involves template parameter(s)", arg);
2652 /* Look at the corresponding template parameter,
2653 marking which template parameters its type depends
2656 TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (main_inner_parms,
2661 /* We haven't yet initialized TPD2. Do so now. */
2662 tpd2.arg_uses_template_parms
2663 = alloca (sizeof (int) * nargs);
2664 /* The number of parameters here is the number in the
2665 main template, which, as checked in the assertion
2667 tpd2.parms = alloca (sizeof (int) * nargs);
2669 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
2672 /* Mark the template parameters. But this time, we're
2673 looking for the template parameters of the main
2674 template, not in the specialization. */
2675 tpd2.current_arg = i;
2676 tpd2.arg_uses_template_parms[i] = 0;
2677 memset (tpd2.parms, 0, sizeof (int) * nargs);
2678 for_each_template_parm (type,
2679 &mark_template_parm,
2683 if (tpd2.arg_uses_template_parms [i])
2685 /* The type depended on some template parameters.
2686 If they are fully specialized in the
2687 specialization, that's OK. */
2689 for (j = 0; j < nargs; ++j)
2690 if (tpd2.parms[j] != 0
2691 && tpd.arg_uses_template_parms [j])
2693 error ("type %qT of template argument %qE depends "
2694 "on template parameter(s)",
2704 if (retrieve_specialization (maintmpl, specargs,
2705 /*class_specializations_p=*/true))
2706 /* We've already got this specialization. */
2709 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
2710 = tree_cons (inner_args, inner_parms,
2711 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
2712 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
2716 /* Check that a template declaration's use of default arguments is not
2717 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
2718 nonzero if DECL is the thing declared by a primary template.
2719 IS_PARTIAL is nonzero if DECL is a partial specialization. */
2722 check_default_tmpl_args (tree decl, tree parms, int is_primary, int is_partial)
2725 int last_level_to_check;
2730 A default template-argument shall not be specified in a
2731 function template declaration or a function template definition, nor
2732 in the template-parameter-list of the definition of a member of a
2735 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
2736 /* You can't have a function template declaration in a local
2737 scope, nor you can you define a member of a class template in a
2741 if (current_class_type
2742 && !TYPE_BEING_DEFINED (current_class_type)
2743 && DECL_LANG_SPECIFIC (decl)
2744 /* If this is either a friend defined in the scope of the class
2745 or a member function. */
2746 && (DECL_FUNCTION_MEMBER_P (decl)
2747 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
2748 : DECL_FRIEND_CONTEXT (decl)
2749 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
2751 /* And, if it was a member function, it really was defined in
2752 the scope of the class. */
2753 && (!DECL_FUNCTION_MEMBER_P (decl)
2754 || DECL_INITIALIZED_IN_CLASS_P (decl)))
2755 /* We already checked these parameters when the template was
2756 declared, so there's no need to do it again now. This function
2757 was defined in class scope, but we're processing it's body now
2758 that the class is complete. */
2763 If a template-parameter has a default template-argument, all
2764 subsequent template-parameters shall have a default
2765 template-argument supplied. */
2766 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
2768 tree inner_parms = TREE_VALUE (parm_level);
2769 int ntparms = TREE_VEC_LENGTH (inner_parms);
2770 int seen_def_arg_p = 0;
2773 for (i = 0; i < ntparms; ++i)
2775 tree parm = TREE_VEC_ELT (inner_parms, i);
2776 if (TREE_PURPOSE (parm))
2778 else if (seen_def_arg_p)
2780 error ("no default argument for %qD", TREE_VALUE (parm));
2781 /* For better subsequent error-recovery, we indicate that
2782 there should have been a default argument. */
2783 TREE_PURPOSE (parm) = error_mark_node;
2788 if (TREE_CODE (decl) != TYPE_DECL || is_partial || !is_primary)
2789 /* For an ordinary class template, default template arguments are
2790 allowed at the innermost level, e.g.:
2791 template <class T = int>
2793 but, in a partial specialization, they're not allowed even
2794 there, as we have in [temp.class.spec]:
2796 The template parameter list of a specialization shall not
2797 contain default template argument values.
2799 So, for a partial specialization, or for a function template,
2800 we look at all of them. */
2803 /* But, for a primary class template that is not a partial
2804 specialization we look at all template parameters except the
2806 parms = TREE_CHAIN (parms);
2808 /* Figure out what error message to issue. */
2809 if (TREE_CODE (decl) == FUNCTION_DECL)
2810 msg = "default template arguments may not be used in function templates";
2811 else if (is_partial)
2812 msg = "default template arguments may not be used in partial specializations";
2814 msg = "default argument for template parameter for class enclosing %qD";
2816 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
2817 /* If we're inside a class definition, there's no need to
2818 examine the parameters to the class itself. On the one
2819 hand, they will be checked when the class is defined, and,
2820 on the other, default arguments are valid in things like:
2821 template <class T = double>
2822 struct S { template <class U> void f(U); };
2823 Here the default argument for `S' has no bearing on the
2824 declaration of `f'. */
2825 last_level_to_check = template_class_depth (current_class_type) + 1;
2827 /* Check everything. */
2828 last_level_to_check = 0;
2830 for (parm_level = parms;
2831 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
2832 parm_level = TREE_CHAIN (parm_level))
2834 tree inner_parms = TREE_VALUE (parm_level);
2838 ntparms = TREE_VEC_LENGTH (inner_parms);
2839 for (i = 0; i < ntparms; ++i)
2840 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
2848 /* Clear out the default argument so that we are not
2850 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
2853 /* At this point, if we're still interested in issuing messages,
2854 they must apply to classes surrounding the object declared. */
2856 msg = "default argument for template parameter for class enclosing %qD";
2860 /* Worker for push_template_decl_real, called via
2861 for_each_template_parm. DATA is really an int, indicating the
2862 level of the parameters we are interested in. If T is a template
2863 parameter of that level, return nonzero. */
2866 template_parm_this_level_p (tree t, void* data)
2868 int this_level = *(int *)data;
2871 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
2872 level = TEMPLATE_PARM_LEVEL (t);
2874 level = TEMPLATE_TYPE_LEVEL (t);
2875 return level == this_level;
2878 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
2879 parameters given by current_template_args, or reuses a
2880 previously existing one, if appropriate. Returns the DECL, or an
2881 equivalent one, if it is replaced via a call to duplicate_decls.
2883 If IS_FRIEND is nonzero, DECL is a friend declaration. */
2886 push_template_decl_real (tree decl, int is_friend)
2894 int new_template_p = 0;
2895 /* True if the template is a member template, in the sense of
2897 bool member_template_p = false;
2899 if (decl == error_mark_node)
2902 /* See if this is a partial specialization. */
2903 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
2904 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
2905 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
2907 is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl));
2910 /* For a friend, we want the context of the friend function, not
2911 the type of which it is a friend. */
2912 ctx = DECL_CONTEXT (decl);
2913 else if (CP_DECL_CONTEXT (decl)
2914 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
2915 /* In the case of a virtual function, we want the class in which
2917 ctx = CP_DECL_CONTEXT (decl);
2919 /* Otherwise, if we're currently defining some class, the DECL
2920 is assumed to be a member of the class. */
2921 ctx = current_scope ();
2923 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
2926 if (!DECL_CONTEXT (decl))
2927 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2929 /* See if this is a primary template. */
2930 primary = template_parm_scope_p ();
2934 if (DECL_CLASS_SCOPE_P (decl))
2935 member_template_p = true;
2936 if (current_lang_name == lang_name_c)
2937 error ("template with C linkage");
2938 else if (TREE_CODE (decl) == TYPE_DECL
2939 && ANON_AGGRNAME_P (DECL_NAME (decl)))
2940 error ("template class without a name");
2941 else if (TREE_CODE (decl) == FUNCTION_DECL)
2943 if (DECL_DESTRUCTOR_P (decl))
2947 A destructor shall not be a member template. */
2948 error ("destructor %qD declared as member template", decl);
2949 return error_mark_node;
2951 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
2952 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
2953 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
2954 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
2955 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
2956 == void_list_node)))
2958 /* [basic.stc.dynamic.allocation]
2960 An allocation function can be a function
2961 template. ... Template allocation functions shall
2962 have two or more parameters. */
2963 error ("invalid template declaration of %qD", decl);
2967 else if ((DECL_IMPLICIT_TYPEDEF_P (decl)
2968 && CLASS_TYPE_P (TREE_TYPE (decl)))
2969 || (TREE_CODE (decl) == VAR_DECL && ctx && CLASS_TYPE_P (ctx)))
2973 error ("template declaration of %q#D", decl);
2974 return error_mark_node;
2978 /* Check to see that the rules regarding the use of default
2979 arguments are not being violated. */
2980 check_default_tmpl_args (decl, current_template_parms,
2981 primary, is_partial);
2984 return process_partial_specialization (decl);
2986 args = current_template_args ();
2989 || TREE_CODE (ctx) == FUNCTION_DECL
2990 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
2991 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
2993 if (DECL_LANG_SPECIFIC (decl)
2994 && DECL_TEMPLATE_INFO (decl)
2995 && DECL_TI_TEMPLATE (decl))
2996 tmpl = DECL_TI_TEMPLATE (decl);
2997 /* If DECL is a TYPE_DECL for a class-template, then there won't
2998 be DECL_LANG_SPECIFIC. The information equivalent to
2999 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3000 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3001 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3002 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3004 /* Since a template declaration already existed for this
3005 class-type, we must be redeclaring it here. Make sure
3006 that the redeclaration is valid. */
3007 redeclare_class_template (TREE_TYPE (decl),
3008 current_template_parms);
3009 /* We don't need to create a new TEMPLATE_DECL; just use the
3010 one we already had. */
3011 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3015 tmpl = build_template_decl (decl, current_template_parms,
3019 if (DECL_LANG_SPECIFIC (decl)
3020 && DECL_TEMPLATE_SPECIALIZATION (decl))
3022 /* A specialization of a member template of a template
3024 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3025 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3026 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3032 tree a, t, current, parms;
3035 if (TREE_CODE (decl) == TYPE_DECL)
3037 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
3038 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
3039 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3040 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3041 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3044 error ("%qD does not declare a template type", decl);
3048 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
3050 error ("template definition of non-template %q#D", decl);
3054 tmpl = DECL_TI_TEMPLATE (decl);
3056 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3057 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3058 && DECL_TEMPLATE_SPECIALIZATION (decl)
3059 && DECL_MEMBER_TEMPLATE_P (tmpl))
3063 /* The declaration is a specialization of a member
3064 template, declared outside the class. Therefore, the
3065 innermost template arguments will be NULL, so we
3066 replace them with the arguments determined by the
3067 earlier call to check_explicit_specialization. */
3068 args = DECL_TI_ARGS (decl);
3071 = build_template_decl (decl, current_template_parms,
3073 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3074 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3075 DECL_TI_TEMPLATE (decl) = new_tmpl;
3076 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3077 DECL_TEMPLATE_INFO (new_tmpl)
3078 = tree_cons (tmpl, args, NULL_TREE);
3080 register_specialization (new_tmpl,
3081 most_general_template (tmpl),
3086 /* Make sure the template headers we got make sense. */
3088 parms = DECL_TEMPLATE_PARMS (tmpl);
3089 i = TMPL_PARMS_DEPTH (parms);
3090 if (TMPL_ARGS_DEPTH (args) != i)
3092 error ("expected %d levels of template parms for %q#D, got %d",
3093 i, decl, TMPL_ARGS_DEPTH (args));
3096 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3098 a = TMPL_ARGS_LEVEL (args, i);
3099 t = INNERMOST_TEMPLATE_PARMS (parms);
3101 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3103 if (current == decl)
3104 error ("got %d template parameters for %q#D",
3105 TREE_VEC_LENGTH (a), decl);
3107 error ("got %d template parameters for %q#T",
3108 TREE_VEC_LENGTH (a), current);
3109 error (" but %d required", TREE_VEC_LENGTH (t));
3112 /* Perhaps we should also check that the parms are used in the
3113 appropriate qualifying scopes in the declarator? */
3115 if (current == decl)
3118 current = TYPE_CONTEXT (current);
3122 DECL_TEMPLATE_RESULT (tmpl) = decl;
3123 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3125 /* Push template declarations for global functions and types. Note
3126 that we do not try to push a global template friend declared in a
3127 template class; such a thing may well depend on the template
3128 parameters of the class. */
3129 if (new_template_p && !ctx
3130 && !(is_friend && template_class_depth (current_class_type) > 0))
3132 tmpl = pushdecl_namespace_level (tmpl);
3133 if (tmpl == error_mark_node)
3134 return error_mark_node;
3139 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3140 if (DECL_CONV_FN_P (tmpl))
3142 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3144 /* It is a conversion operator. See if the type converted to
3145 depends on innermost template operands. */
3147 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3149 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3153 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3154 back to its most general template. If TMPL is a specialization,
3155 ARGS may only have the innermost set of arguments. Add the missing
3156 argument levels if necessary. */
3157 if (DECL_TEMPLATE_INFO (tmpl))
3158 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3160 info = tree_cons (tmpl, args, NULL_TREE);
3162 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3164 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3165 if ((!ctx || TREE_CODE (ctx) != FUNCTION_DECL)
3166 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3167 /* Don't change the name if we've already set it up. */
3168 && !IDENTIFIER_TEMPLATE (DECL_NAME (decl)))
3169 DECL_NAME (decl) = classtype_mangled_name (TREE_TYPE (decl));
3171 else if (DECL_LANG_SPECIFIC (decl))
3172 DECL_TEMPLATE_INFO (decl) = info;
3174 return DECL_TEMPLATE_RESULT (tmpl);
3178 push_template_decl (tree decl)
3180 return push_template_decl_real (decl, 0);
3183 /* Called when a class template TYPE is redeclared with the indicated
3184 template PARMS, e.g.:
3186 template <class T> struct S;
3187 template <class T> struct S {}; */
3190 redeclare_class_template (tree type, tree parms)
3196 if (!TYPE_TEMPLATE_INFO (type))
3198 error ("%qT is not a template type", type);
3202 tmpl = TYPE_TI_TEMPLATE (type);
3203 if (!PRIMARY_TEMPLATE_P (tmpl))
3204 /* The type is nested in some template class. Nothing to worry
3205 about here; there are no new template parameters for the nested
3211 error ("template specifiers not specified in declaration of %qD",
3216 parms = INNERMOST_TEMPLATE_PARMS (parms);
3217 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
3219 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
3221 cp_error_at ("previous declaration %qD", tmpl);
3222 error ("used %d template parameter%s instead of %d",
3223 TREE_VEC_LENGTH (tmpl_parms),
3224 TREE_VEC_LENGTH (tmpl_parms) == 1 ? "" : "s",
3225 TREE_VEC_LENGTH (parms));
3229 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
3231 tree tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
3232 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
3233 tree tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
3234 tree parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
3236 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
3238 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
3239 || (TREE_CODE (tmpl_parm) != TYPE_DECL
3240 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm))))
3242 cp_error_at ("template parameter %q#D", tmpl_parm);
3243 error ("redeclared here as %q#D", parm);
3247 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
3249 /* We have in [temp.param]:
3251 A template-parameter may not be given default arguments
3252 by two different declarations in the same scope. */
3253 error ("redefinition of default argument for %q#D", parm);
3254 error ("%J original definition appeared here", tmpl_parm);
3258 if (parm_default != NULL_TREE)
3259 /* Update the previous template parameters (which are the ones
3260 that will really count) with the new default value. */
3261 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
3262 else if (tmpl_default != NULL_TREE)
3263 /* Update the new parameters, too; they'll be used as the
3264 parameters for any members. */
3265 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
3269 /* Return true if non-dependent expressions EXPR contains within it a
3270 cast expression with a dependent argument. */
3273 contains_dependent_cast_p (tree expr)
3275 switch (TREE_CODE (expr))
3278 case REINTERPRET_CAST_EXPR:
3279 case STATIC_CAST_EXPR:
3280 case DYNAMIC_CAST_EXPR:
3281 case CONST_CAST_EXPR:
3283 tree op = TREE_OPERAND (expr, 0);
3285 if (op && (type_dependent_expression_p (op)
3286 || value_dependent_expression_p (op)))
3292 /* The operands of a CALL_EXPR are held as a list. */
3293 for (; expr; expr = TREE_CHAIN (expr))
3294 if (contains_dependent_cast_p (TREE_VALUE (expr)))
3302 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
3306 for (ix = TREE_CODE_LENGTH (TREE_CODE (expr)); ix--;)
3307 if (TREE_OPERAND (expr, ix)
3308 && contains_dependent_cast_p (TREE_OPERAND (expr, ix)))
3315 /* Simplify EXPR if it is a non-dependent expression. Returns the
3316 (possibly simplified) expression. */
3319 fold_non_dependent_expr (tree expr)
3321 /* If we're in a template, but EXPR isn't value dependent, simplify
3322 it. We're supposed to treat:
3324 template <typename T> void f(T[1 + 1]);
3325 template <typename T> void f(T[2]);
3327 as two declarations of the same function, for example. */
3328 if (processing_template_decl
3329 && !type_dependent_expression_p (expr)
3330 && !value_dependent_expression_p (expr)
3331 && !contains_dependent_cast_p (expr))
3333 HOST_WIDE_INT saved_processing_template_decl;
3335 saved_processing_template_decl = processing_template_decl;
3336 processing_template_decl = 0;
3337 expr = tsubst_copy_and_build (expr,
3340 /*in_decl=*/NULL_TREE,
3341 /*function_p=*/false);
3342 processing_template_decl = saved_processing_template_decl;
3347 /* EXPR is an expression which is used in a constant-expression context.
3348 For instance, it could be a VAR_DECL with a constant initializer.
3349 Extract the innest constant expression.
3351 This is basically a more powerful version of
3352 integral_constant_value, which can be used also in templates where
3353 initializers can maintain a syntactic rather than semantic form
3354 (even if they are non-dependent, for access-checking purposes). */
3357 fold_decl_constant_value (tree expr)
3359 tree const_expr = expr;
3362 expr = fold_non_dependent_expr (const_expr);
3363 const_expr = integral_constant_value (expr);
3365 while (expr != const_expr);
3370 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
3371 must be a function or a pointer-to-function type, as specified
3372 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
3373 and check that the resulting function has external linkage. */
3376 convert_nontype_argument_function (tree type, tree expr)
3381 fn = instantiate_type (type, fns, tf_none);
3382 if (fn == error_mark_node)
3383 return error_mark_node;
3386 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
3387 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
3389 /* [temp.arg.nontype]/1
3391 A template-argument for a non-type, non-template template-parameter
3394 -- the address of an object or function with external linkage. */
3395 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
3397 error ("%qE is not a valid template argument for type %qT "
3398 "because function %qD has not external linkage",
3399 expr, type, fn_no_ptr);
3406 /* Attempt to convert the non-type template parameter EXPR to the
3407 indicated TYPE. If the conversion is successful, return the
3408 converted value. If the conversion is unsuccessful, return
3409 NULL_TREE if we issued an error message, or error_mark_node if we
3410 did not. We issue error messages for out-and-out bad template
3411 parameters, but not simply because the conversion failed, since we
3412 might be just trying to do argument deduction. Both TYPE and EXPR
3413 must be non-dependent.
3415 The conversion follows the special rules described in
3416 [temp.arg.nontype], and it is much more strict than an implicit
3419 This function is called twice for each template argument (see
3420 lookup_template_class for a more accurate description of this
3421 problem). This means that we need to handle expressions which
3422 are not valid in a C++ source, but can be created from the
3423 first call (for instance, casts to perform conversions). These
3424 hacks can go away after we fix the double coercion problem. */
3427 convert_nontype_argument (tree type, tree expr)
3431 /* Detect immediately string literals as invalid non-type argument.
3432 This special-case is not needed for correctness (we would easily
3433 catch this later), but only to provide better diagnostic for this
3434 common user mistake. As suggested by DR 100, we do not mention
3435 linkage issues in the diagnostic as this is not the point. */
3436 if (TREE_CODE (expr) == STRING_CST)
3438 error ("%qE is not a valid template argument for type %qT "
3439 "because string literals can never be used in this context",
3444 /* If we are in a template, EXPR may be non-dependent, but still
3445 have a syntactic, rather than semantic, form. For example, EXPR
3446 might be a SCOPE_REF, rather than the VAR_DECL to which the
3447 SCOPE_REF refers. Preserving the qualifying scope is necessary
3448 so that access checking can be performed when the template is
3449 instantiated -- but here we need the resolved form so that we can
3450 convert the argument. */
3451 expr = fold_non_dependent_expr (expr);
3452 expr_type = TREE_TYPE (expr);
3454 /* HACK: Due to double coercion, we can get a
3455 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
3456 which is the tree that we built on the first call (see
3457 below when coercing to reference to object or to reference to
3458 function). We just strip everything and get to the arg.
3459 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
3461 if (TREE_CODE (expr) == NOP_EXPR)
3463 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
3465 /* ??? Maybe we could use convert_from_reference here, but we
3466 would need to relax its constraints because the NOP_EXPR
3467 could actually change the type to something more cv-qualified,
3468 and this is not folded by convert_from_reference. */
3469 tree addr = TREE_OPERAND (expr, 0);
3470 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
3471 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
3472 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
3473 gcc_assert (same_type_ignoring_top_level_qualifiers_p
3474 (TREE_TYPE (expr_type),
3475 TREE_TYPE (TREE_TYPE (addr))));
3477 expr = TREE_OPERAND (addr, 0);
3478 expr_type = TREE_TYPE (expr);
3481 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
3482 parameter is a pointer to object, through decay and
3483 qualification conversion. Let's strip everything. */
3484 else if (TYPE_PTROBV_P (type))
3487 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
3488 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
3489 /* Skip the ADDR_EXPR only if it is part of the decay for
3490 an array. Otherwise, it is part of the original argument
3491 in the source code. */
3492 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
3493 expr = TREE_OPERAND (expr, 0);
3494 expr_type = TREE_TYPE (expr);
3498 /* [temp.arg.nontype]/5, bullet 1
3500 For a non-type template-parameter of integral or enumeration type,
3501 integral promotions (_conv.prom_) and integral conversions
3502 (_conv.integral_) are applied. */
3503 if (INTEGRAL_TYPE_P (type))
3505 if (!INTEGRAL_TYPE_P (expr_type))
3506 return error_mark_node;
3508 expr = fold_decl_constant_value (expr);
3509 /* Notice that there are constant expressions like '4 % 0' which
3510 do not fold into integer constants. */
3511 if (TREE_CODE (expr) != INTEGER_CST)
3513 error ("%qE is not a valid template argument for type %qT "
3514 "because it is a non-constant expression", expr, type);
3518 /* At this point, an implicit conversion does what we want,
3519 because we already know that the expression is of integral
3521 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
3522 if (expr == error_mark_node)
3523 return error_mark_node;
3525 /* Conversion was allowed: fold it to a bare integer constant. */
3528 /* [temp.arg.nontype]/5, bullet 2
3530 For a non-type template-parameter of type pointer to object,
3531 qualification conversions (_conv.qual_) and the array-to-pointer
3532 conversion (_conv.array_) are applied. */
3533 else if (TYPE_PTROBV_P (type))
3535 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
3537 A template-argument for a non-type, non-template template-parameter
3538 shall be one of: [...]
3540 -- the name of a non-type template-parameter;
3541 -- the address of an object or function with external linkage, [...]
3542 expressed as "& id-expression" where the & is optional if the name
3543 refers to a function or array, or if the corresponding
3544 template-parameter is a reference.
3546 Here, we do not care about functions, as they are invalid anyway
3547 for a parameter of type pointer-to-object. */
3548 bool constant_address_p =
3549 (TREE_CODE (expr) == ADDR_EXPR
3550 || TREE_CODE (expr_type) == ARRAY_TYPE
3551 || (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr)));
3553 expr = decay_conversion (expr);
3554 if (expr == error_mark_node)
3555 return error_mark_node;
3557 expr = perform_qualification_conversions (type, expr);
3558 if (expr == error_mark_node)
3559 return error_mark_node;
3561 if (!constant_address_p)
3563 error ("%qE is not a valid template argument for type %qT "
3564 "because it is not a constant pointer", expr, type);
3568 /* [temp.arg.nontype]/5, bullet 3
3570 For a non-type template-parameter of type reference to object, no
3571 conversions apply. The type referred to by the reference may be more
3572 cv-qualified than the (otherwise identical) type of the
3573 template-argument. The template-parameter is bound directly to the
3574 template-argument, which must be an lvalue. */
3575 else if (TYPE_REF_OBJ_P (type))
3577 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
3579 return error_mark_node;
3581 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
3583 error ("%qE is not a valid template argument for type %qT "
3584 "because of conflicts in cv-qualification", expr, type);
3588 if (!real_lvalue_p (expr))
3590 error ("%qE is not a valid template argument for type %qT "
3591 "because it is not a lvalue", expr, type);
3595 /* [temp.arg.nontype]/1
3597 A template-argument for a non-type, non-template template-parameter
3598 shall be one of: [...]
3600 -- the address of an object or function with external linkage. */
3601 if (!DECL_EXTERNAL_LINKAGE_P (expr))
3603 error ("%qE is not a valid template argument for type %qT "
3604 "because object %qD has not external linkage",
3609 expr = build_nop (type, build_address (expr));
3611 /* [temp.arg.nontype]/5, bullet 4
3613 For a non-type template-parameter of type pointer to function, only
3614 the function-to-pointer conversion (_conv.func_) is applied. If the
3615 template-argument represents a set of overloaded functions (or a
3616 pointer to such), the matching function is selected from the set
3618 else if (TYPE_PTRFN_P (type))
3620 /* If the argument is a template-id, we might not have enough
3621 context information to decay the pointer.
3622 ??? Why static5.C requires decay and subst1.C works fine
3624 if (!type_unknown_p (expr_type))
3626 expr = decay_conversion (expr);
3627 if (expr == error_mark_node)
3628 return error_mark_node;
3631 expr = convert_nontype_argument_function (type, expr);
3632 if (!expr || expr == error_mark_node)
3635 /* [temp.arg.nontype]/5, bullet 5
3637 For a non-type template-parameter of type reference to function, no
3638 conversions apply. If the template-argument represents a set of
3639 overloaded functions, the matching function is selected from the set
3641 else if (TYPE_REFFN_P (type))
3643 if (TREE_CODE (expr) == ADDR_EXPR)
3645 error ("%qE is not a valid template argument for type %qT "
3646 "because it is a pointer", expr, type);
3647 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
3651 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
3652 if (!expr || expr == error_mark_node)
3655 expr = build_nop(type, build_address (expr));
3657 /* [temp.arg.nontype]/5, bullet 6
3659 For a non-type template-parameter of type pointer to member function,
3660 no conversions apply. If the template-argument represents a set of
3661 overloaded member functions, the matching member function is selected
3662 from the set (_over.over_). */
3663 else if (TYPE_PTRMEMFUNC_P (type))
3665 expr = instantiate_type (type, expr, tf_none);
3666 if (expr == error_mark_node)
3667 return error_mark_node;
3669 /* There is no way to disable standard conversions in
3670 resolve_address_of_overloaded_function (called by
3671 instantiate_type). It is possible that the call succeeded by
3672 converting &B::I to &D::I (where B is a base of D), so we need
3673 to reject this conversion here.
3675 Actually, even if there was a way to disable standard conversions,
3676 it would still be better to reject them here so that we can
3677 provide a superior diagnostic. */
3678 if (!same_type_p (TREE_TYPE (expr), type))
3680 /* Make sure we are just one standard conversion off. */
3681 gcc_assert (can_convert (type, TREE_TYPE (expr)));
3682 error ("%qE is not a valid template argument for type %qT "
3683 "because it is of type %qT", expr, type,
3685 inform ("standard conversions are not allowed in this context");
3689 /* [temp.arg.nontype]/5, bullet 7
3691 For a non-type template-parameter of type pointer to data member,
3692 qualification conversions (_conv.qual_) are applied. */
3693 else if (TYPE_PTRMEM_P (type))
3695 expr = perform_qualification_conversions (type, expr);
3696 if (expr == error_mark_node)
3699 /* A template non-type parameter must be one of the above. */
3703 /* Sanity check: did we actually convert the argument to the
3705 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
3710 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
3711 template template parameters. Both PARM_PARMS and ARG_PARMS are
3712 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
3715 ARG_PARMS may contain more parameters than PARM_PARMS. If this is
3716 the case, then extra parameters must have default arguments.
3718 Consider the example:
3719 template <class T, class Allocator = allocator> class vector;
3720 template<template <class U> class TT> class C;
3722 C<vector> is a valid instantiation. PARM_PARMS for the above code
3723 contains a TYPE_DECL (for U), ARG_PARMS contains two TYPE_DECLs (for
3724 T and Allocator) and OUTER_ARGS contains the argument that is used to
3725 substitute the TT parameter. */
3728 coerce_template_template_parms (tree parm_parms,
3730 tsubst_flags_t complain,
3734 int nparms, nargs, i;
3737 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
3738 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
3740 nparms = TREE_VEC_LENGTH (parm_parms);
3741 nargs = TREE_VEC_LENGTH (arg_parms);
3743 /* The rule here is opposite of coerce_template_parms. */
3746 && TREE_PURPOSE (TREE_VEC_ELT (arg_parms, nparms)) == NULL_TREE))
3749 for (i = 0; i < nparms; ++i)
3751 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
3752 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
3754 if (arg == NULL_TREE || arg == error_mark_node
3755 || parm == NULL_TREE || parm == error_mark_node)
3758 if (TREE_CODE (arg) != TREE_CODE (parm))
3761 switch (TREE_CODE (parm))
3767 /* We encounter instantiations of templates like
3768 template <template <template <class> class> class TT>
3771 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3772 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3774 if (!coerce_template_template_parms
3775 (parmparm, argparm, complain, in_decl, outer_args))
3781 /* The tsubst call is used to handle cases such as
3783 template <int> class C {};
3784 template <class T, template <T> class TT> class D {};
3787 i.e. the parameter list of TT depends on earlier parameters. */
3788 if (!dependent_type_p (TREE_TYPE (arg))
3790 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
3802 /* Convert the indicated template ARG as necessary to match the
3803 indicated template PARM. Returns the converted ARG, or
3804 error_mark_node if the conversion was unsuccessful. Error and
3805 warning messages are issued under control of COMPLAIN. This
3806 conversion is for the Ith parameter in the parameter list. ARGS is
3807 the full set of template arguments deduced so far. */
3810 convert_template_argument (tree parm,
3813 tsubst_flags_t complain,
3819 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
3821 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3823 if (TREE_CODE (arg) == TREE_LIST
3824 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
3826 /* The template argument was the name of some
3827 member function. That's usually
3828 invalid, but static members are OK. In any
3829 case, grab the underlying fields/functions
3830 and issue an error later if required. */
3831 arg = TREE_VALUE (arg);
3832 TREE_TYPE (arg) = unknown_type_node;
3835 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
3836 requires_type = (TREE_CODE (parm) == TYPE_DECL
3837 || requires_tmpl_type);
3839 is_tmpl_type = ((TREE_CODE (arg) == TEMPLATE_DECL
3840 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
3841 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3842 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
3845 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3846 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
3847 arg = TYPE_STUB_DECL (arg);
3849 is_type = TYPE_P (arg) || is_tmpl_type;
3851 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
3852 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
3854 pedwarn ("to refer to a type member of a template parameter, "
3855 "use %<typename %E%>", arg);
3857 arg = make_typename_type (TREE_OPERAND (arg, 0),
3858 TREE_OPERAND (arg, 1),
3860 complain & tf_error);
3863 if (is_type != requires_type)
3867 if (complain & tf_error)
3869 error ("type/value mismatch at argument %d in template "
3870 "parameter list for %qD",
3873 error (" expected a constant of type %qT, got %qT",
3875 (is_tmpl_type ? DECL_NAME (arg) : arg));
3876 else if (requires_tmpl_type)
3877 error (" expected a class template, got %qE", arg);
3879 error (" expected a type, got %qE", arg);
3882 return error_mark_node;
3884 if (is_tmpl_type ^ requires_tmpl_type)
3886 if (in_decl && (complain & tf_error))
3888 error ("type/value mismatch at argument %d in template "
3889 "parameter list for %qD",
3892 error (" expected a type, got %qT", DECL_NAME (arg));
3894 error (" expected a class template, got %qT", arg);
3896 return error_mark_node;
3901 if (requires_tmpl_type)
3903 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
3904 /* The number of argument required is not known yet.
3905 Just accept it for now. */
3906 val = TREE_TYPE (arg);
3909 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
3910 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
3912 if (coerce_template_template_parms (parmparm, argparm,
3918 /* TEMPLATE_TEMPLATE_PARM node is preferred over
3920 if (val != error_mark_node
3921 && DECL_TEMPLATE_TEMPLATE_PARM_P (val))
3922 val = TREE_TYPE (val);
3926 if (in_decl && (complain & tf_error))
3928 error ("type/value mismatch at argument %d in "
3929 "template parameter list for %qD",
3931 error (" expected a template of type %qD, got %qD",
3935 val = error_mark_node;
3944 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
3946 if (invalid_nontype_parm_type_p (t, complain))
3947 return error_mark_node;
3949 if (!uses_template_parms (arg) && !uses_template_parms (t))
3950 /* We used to call digest_init here. However, digest_init
3951 will report errors, which we don't want when complain
3952 is zero. More importantly, digest_init will try too
3953 hard to convert things: for example, `0' should not be
3954 converted to pointer type at this point according to
3955 the standard. Accepting this is not merely an
3956 extension, since deciding whether or not these
3957 conversions can occur is part of determining which
3958 function template to call, or whether a given explicit
3959 argument specification is valid. */
3960 val = convert_nontype_argument (t, arg);
3964 if (val == NULL_TREE)
3965 val = error_mark_node;
3966 else if (val == error_mark_node && (complain & tf_error))
3967 error ("could not convert template argument %qE to %qT", arg, t);
3973 /* Convert all template arguments to their appropriate types, and
3974 return a vector containing the innermost resulting template
3975 arguments. If any error occurs, return error_mark_node. Error and
3976 warning messages are issued under control of COMPLAIN.
3978 If REQUIRE_ALL_ARGUMENTS is nonzero, all arguments must be
3979 provided in ARGLIST, or else trailing parameters must have default
3980 values. If REQUIRE_ALL_ARGUMENTS is zero, we will attempt argument
3981 deduction for any unspecified trailing arguments. */
3984 coerce_template_parms (tree parms,
3987 tsubst_flags_t complain,
3988 int require_all_arguments)
3990 int nparms, nargs, i, lost = 0;
3993 tree new_inner_args;
3995 inner_args = INNERMOST_TEMPLATE_ARGS (args);
3996 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
3997 nparms = TREE_VEC_LENGTH (parms);
4001 && require_all_arguments
4002 && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE))
4004 if (complain & tf_error)
4006 error ("wrong number of template arguments (%d, should be %d)",
4010 cp_error_at ("provided for %qD", in_decl);
4013 return error_mark_node;
4016 new_inner_args = make_tree_vec (nparms);
4017 new_args = add_outermost_template_args (args, new_inner_args);
4018 for (i = 0; i < nparms; i++)
4023 /* Get the Ith template parameter. */
4024 parm = TREE_VEC_ELT (parms, i);
4026 /* Calculate the Ith argument. */
4028 arg = TREE_VEC_ELT (inner_args, i);
4029 else if (require_all_arguments)
4030 /* There must be a default arg in this case. */
4031 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
4037 if (arg == error_mark_node)
4039 if (complain & tf_error)
4040 error ("template argument %d is invalid", i + 1);
4043 arg = convert_template_argument (TREE_VALUE (parm),
4044 arg, new_args, complain, i,
4047 if (arg == error_mark_node)
4049 TREE_VEC_ELT (new_inner_args, i) = arg;
4053 return error_mark_node;
4055 return new_inner_args;
4058 /* Returns 1 if template args OT and NT are equivalent. */
4061 template_args_equal (tree ot, tree nt)
4066 if (TREE_CODE (nt) == TREE_VEC)
4067 /* For member templates */
4068 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
4069 else if (TYPE_P (nt))
4070 return TYPE_P (ot) && same_type_p (ot, nt);
4071 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
4074 return cp_tree_equal (ot, nt);
4077 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
4078 of template arguments. Returns 0 otherwise. */
4081 comp_template_args (tree oldargs, tree newargs)
4085 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
4088 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
4090 tree nt = TREE_VEC_ELT (newargs, i);
4091 tree ot = TREE_VEC_ELT (oldargs, i);
4093 if (! template_args_equal (ot, nt))
4099 /* Given class template name and parameter list, produce a user-friendly name
4100 for the instantiation. */
4103 mangle_class_name_for_template (const char* name, tree parms, tree arglist)
4105 static struct obstack scratch_obstack;
4106 static char *scratch_firstobj;
4109 if (!scratch_firstobj)
4110 gcc_obstack_init (&scratch_obstack);
4112 obstack_free (&scratch_obstack, scratch_firstobj);
4113 scratch_firstobj = obstack_alloc (&scratch_obstack, 1);
4115 #define ccat(C) obstack_1grow (&scratch_obstack, (C));
4116 #define cat(S) obstack_grow (&scratch_obstack, (S), strlen (S))
4120 nparms = TREE_VEC_LENGTH (parms);
4121 arglist = INNERMOST_TEMPLATE_ARGS (arglist);
4122 gcc_assert (nparms == TREE_VEC_LENGTH (arglist));
4123 for (i = 0; i < nparms; i++)
4125 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4126 tree arg = TREE_VEC_ELT (arglist, i);
4131 if (TREE_CODE (parm) == TYPE_DECL)
4133 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4136 else if (TREE_CODE (parm) == TEMPLATE_DECL)
4138 if (TREE_CODE (arg) == TEMPLATE_DECL)
4140 /* Already substituted with real template. Just output
4141 the template name here */
4142 tree context = DECL_CONTEXT (arg);
4145 /* The template may be defined in a namespace, or
4146 may be a member template. */
4147 gcc_assert (TREE_CODE (context) == NAMESPACE_DECL
4148 || CLASS_TYPE_P (context));
4149 cat (decl_as_string (DECL_CONTEXT (arg),
4150 TFF_PLAIN_IDENTIFIER));
4153 cat (IDENTIFIER_POINTER (DECL_NAME (arg)));
4156 /* Output the parameter declaration. */
4157 cat (type_as_string (arg, TFF_CHASE_TYPEDEF));
4161 gcc_assert (TREE_CODE (parm) == PARM_DECL);
4163 /* No need to check arglist against parmlist here; we did that
4164 in coerce_template_parms, called from lookup_template_class. */
4165 cat (expr_as_string (arg, TFF_PLAIN_IDENTIFIER));
4168 char *bufp = obstack_next_free (&scratch_obstack);
4170 while (bufp[offset - 1] == ' ')
4172 obstack_blank_fast (&scratch_obstack, offset);
4174 /* B<C<char> >, not B<C<char>> */
4175 if (bufp[offset - 1] == '>')
4180 return (char *) obstack_base (&scratch_obstack);
4184 classtype_mangled_name (tree t)
4186 if (CLASSTYPE_TEMPLATE_INFO (t)
4187 /* Specializations have already had their names set up in
4188 lookup_template_class. */
4189 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
4191 tree tmpl = most_general_template (CLASSTYPE_TI_TEMPLATE (t));
4193 /* For non-primary templates, the template parameters are
4194 implicit from their surrounding context. */
4195 if (PRIMARY_TEMPLATE_P (tmpl))
4197 tree name = DECL_NAME (tmpl);
4198 char *mangled_name = mangle_class_name_for_template
4199 (IDENTIFIER_POINTER (name),
4200 DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
4201 CLASSTYPE_TI_ARGS (t));
4202 tree id = get_identifier (mangled_name);
4203 IDENTIFIER_TEMPLATE (id) = name;
4208 return TYPE_IDENTIFIER (t);
4212 add_pending_template (tree d)
4214 tree ti = (TYPE_P (d)
4215 ? CLASSTYPE_TEMPLATE_INFO (d)
4216 : DECL_TEMPLATE_INFO (d));
4220 if (TI_PENDING_TEMPLATE_FLAG (ti))
4223 /* We are called both from instantiate_decl, where we've already had a
4224 tinst_level pushed, and instantiate_template, where we haven't.
4226 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
4229 push_tinst_level (d);
4231 pt = tree_cons (current_tinst_level, d, NULL_TREE);
4232 if (last_pending_template)
4233 TREE_CHAIN (last_pending_template) = pt;
4235 pending_templates = pt;
4237 last_pending_template = pt;
4239 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
4246 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
4247 ARGLIST. Valid choices for FNS are given in the cp-tree.def
4248 documentation for TEMPLATE_ID_EXPR. */
4251 lookup_template_function (tree fns, tree arglist)
4255 if (fns == error_mark_node || arglist == error_mark_node)
4256 return error_mark_node;
4258 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
4259 gcc_assert (fns && (is_overloaded_fn (fns)
4260 || TREE_CODE (fns) == IDENTIFIER_NODE));
4262 if (BASELINK_P (fns))
4264 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
4266 BASELINK_FUNCTIONS (fns),
4271 type = TREE_TYPE (fns);
4272 if (TREE_CODE (fns) == OVERLOAD || !type)
4273 type = unknown_type_node;
4275 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
4278 /* Within the scope of a template class S<T>, the name S gets bound
4279 (in build_self_reference) to a TYPE_DECL for the class, not a
4280 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
4281 or one of its enclosing classes, and that type is a template,
4282 return the associated TEMPLATE_DECL. Otherwise, the original
4283 DECL is returned. */
4286 maybe_get_template_decl_from_type_decl (tree decl)
4288 return (decl != NULL_TREE
4289 && TREE_CODE (decl) == TYPE_DECL
4290 && DECL_ARTIFICIAL (decl)
4291 && CLASS_TYPE_P (TREE_TYPE (decl))
4292 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
4293 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
4296 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
4297 parameters, find the desired type.
4299 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
4301 IN_DECL, if non-NULL, is the template declaration we are trying to
4304 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4305 the class we are looking up.
4307 Issue error and warning messages under control of COMPLAIN.
4309 If the template class is really a local class in a template
4310 function, then the FUNCTION_CONTEXT is the function in which it is
4313 ??? Note that this function is currently called *twice* for each
4314 template-id: the first time from the parser, while creating the
4315 incomplete type (finish_template_type), and the second type during the
4316 real instantiation (instantiate_template_class). This is surely something
4317 that we want to avoid. It also causes some problems with argument
4318 coercion (see convert_nontype_argument for more information on this). */
4321 lookup_template_class (tree d1,
4326 tsubst_flags_t complain)
4328 tree template = NULL_TREE, parmlist;
4331 timevar_push (TV_NAME_LOOKUP);
4333 if (TREE_CODE (d1) == IDENTIFIER_NODE)
4335 tree value = innermost_non_namespace_value (d1);
4336 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
4341 push_decl_namespace (context);
4342 template = lookup_name (d1, /*prefer_type=*/0);
4343 template = maybe_get_template_decl_from_type_decl (template);
4345 pop_decl_namespace ();
4348 context = DECL_CONTEXT (template);
4350 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
4352 tree type = TREE_TYPE (d1);
4354 /* If we are declaring a constructor, say A<T>::A<T>, we will get
4355 an implicit typename for the second A. Deal with it. */
4356 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4357 type = TREE_TYPE (type);
4359 if (CLASSTYPE_TEMPLATE_INFO (type))
4361 template = CLASSTYPE_TI_TEMPLATE (type);
4362 d1 = DECL_NAME (template);
4365 else if (TREE_CODE (d1) == ENUMERAL_TYPE
4366 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
4368 template = TYPE_TI_TEMPLATE (d1);
4369 d1 = DECL_NAME (template);
4371 else if (TREE_CODE (d1) == TEMPLATE_DECL
4372 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
4375 d1 = DECL_NAME (template);
4376 context = DECL_CONTEXT (template);
4379 /* Issue an error message if we didn't find a template. */
4382 if (complain & tf_error)
4383 error ("%qT is not a template", d1);
4384 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4387 if (TREE_CODE (template) != TEMPLATE_DECL
4388 /* Make sure it's a user visible template, if it was named by
4390 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
4391 && !PRIMARY_TEMPLATE_P (template)))
4393 if (complain & tf_error)
4395 error ("non-template type %qT used as a template", d1);
4397 cp_error_at ("for template declaration %qD", in_decl);
4399 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4402 complain &= ~tf_user;
4404 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
4406 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
4407 template arguments */
4412 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
4414 /* Consider an example where a template template parameter declared as
4416 template <class T, class U = std::allocator<T> > class TT
4418 The template parameter level of T and U are one level larger than
4419 of TT. To proper process the default argument of U, say when an
4420 instantiation `TT<int>' is seen, we need to build the full
4421 arguments containing {int} as the innermost level. Outer levels,
4422 available when not appearing as default template argument, can be
4423 obtained from `current_template_args ()'.
4425 Suppose that TT is later substituted with std::vector. The above
4426 instantiation is `TT<int, std::allocator<T> >' with TT at
4427 level 1, and T at level 2, while the template arguments at level 1
4428 becomes {std::vector} and the inner level 2 is {int}. */
4430 if (current_template_parms)
4431 arglist = add_to_template_args (current_template_args (), arglist);
4433 arglist2 = coerce_template_parms (parmlist, arglist, template,
4434 complain, /*require_all_args=*/1);
4435 if (arglist2 == error_mark_node
4436 || (!uses_template_parms (arglist2)
4437 && check_instantiated_args (template, arglist2, complain)))
4438 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4440 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
4441 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
4445 tree template_type = TREE_TYPE (template);
4448 tree found = NULL_TREE;
4451 int is_partial_instantiation;
4453 gen_tmpl = most_general_template (template);
4454 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
4455 parm_depth = TMPL_PARMS_DEPTH (parmlist);
4456 arg_depth = TMPL_ARGS_DEPTH (arglist);
4458 if (arg_depth == 1 && parm_depth > 1)
4460 /* We've been given an incomplete set of template arguments.
4463 template <class T> struct S1 {
4464 template <class U> struct S2 {};
4465 template <class U> struct S2<U*> {};
4468 we will be called with an ARGLIST of `U*', but the
4469 TEMPLATE will be `template <class T> template
4470 <class U> struct S1<T>::S2'. We must fill in the missing
4473 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
4475 arg_depth = TMPL_ARGS_DEPTH (arglist);
4478 /* Now we should have enough arguments. */
4479 gcc_assert (parm_depth == arg_depth);
4481 /* From here on, we're only interested in the most general
4483 template = gen_tmpl;
4485 /* Calculate the BOUND_ARGS. These will be the args that are
4486 actually tsubst'd into the definition to create the
4490 /* We have multiple levels of arguments to coerce, at once. */
4492 int saved_depth = TMPL_ARGS_DEPTH (arglist);
4494 tree bound_args = make_tree_vec (parm_depth);
4496 for (i = saved_depth,
4497 t = DECL_TEMPLATE_PARMS (template);
4498 i > 0 && t != NULL_TREE;
4499 --i, t = TREE_CHAIN (t))
4501 tree a = coerce_template_parms (TREE_VALUE (t),
4503 complain, /*require_all_args=*/1);
4505 /* Don't process further if one of the levels fails. */
4506 if (a == error_mark_node)
4508 /* Restore the ARGLIST to its full size. */
4509 TREE_VEC_LENGTH (arglist) = saved_depth;
4510 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4513 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
4515 /* We temporarily reduce the length of the ARGLIST so
4516 that coerce_template_parms will see only the arguments
4517 corresponding to the template parameters it is
4519 TREE_VEC_LENGTH (arglist)--;
4522 /* Restore the ARGLIST to its full size. */
4523 TREE_VEC_LENGTH (arglist) = saved_depth;
4525 arglist = bound_args;
4529 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
4530 INNERMOST_TEMPLATE_ARGS (arglist),
4532 complain, /*require_all_args=*/1);
4534 if (arglist == error_mark_node)
4535 /* We were unable to bind the arguments. */
4536 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4538 /* In the scope of a template class, explicit references to the
4539 template class refer to the type of the template, not any
4540 instantiation of it. For example, in:
4542 template <class T> class C { void f(C<T>); }
4544 the `C<T>' is just the same as `C'. Outside of the
4545 class, however, such a reference is an instantiation. */
4546 if (comp_template_args (TYPE_TI_ARGS (template_type),
4549 found = template_type;
4551 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
4555 for (ctx = current_class_type;
4556 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
4558 ? TYPE_CONTEXT (ctx)
4559 : DECL_CONTEXT (ctx)))
4560 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
4563 /* We're not in the scope of the class, so the
4564 TEMPLATE_TYPE is not the type we want after all. */
4570 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4572 /* If we already have this specialization, return it. */
4573 found = retrieve_specialization (template, arglist,
4574 /*class_specializations_p=*/false);
4576 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4578 /* This type is a "partial instantiation" if any of the template
4579 arguments still involve template parameters. Note that we set
4580 IS_PARTIAL_INSTANTIATION for partial specializations as
4582 is_partial_instantiation = uses_template_parms (arglist);
4584 /* If the deduced arguments are invalid, then the binding
4586 if (!is_partial_instantiation
4587 && check_instantiated_args (template,
4588 INNERMOST_TEMPLATE_ARGS (arglist),
4590 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4592 if (!is_partial_instantiation
4593 && !PRIMARY_TEMPLATE_P (template)
4594 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
4596 found = xref_tag_from_type (TREE_TYPE (template),
4597 DECL_NAME (template),
4598 /*tag_scope=*/ts_global);
4599 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
4602 context = tsubst (DECL_CONTEXT (template), arglist,
4605 context = global_namespace;
4607 /* Create the type. */
4608 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
4610 if (!is_partial_instantiation)
4612 set_current_access_from_decl (TYPE_NAME (template_type));
4613 t = start_enum (TYPE_IDENTIFIER (template_type));
4616 /* We don't want to call start_enum for this type, since
4617 the values for the enumeration constants may involve
4618 template parameters. And, no one should be interested
4619 in the enumeration constants for such a type. */
4620 t = make_node (ENUMERAL_TYPE);
4624 t = make_aggr_type (TREE_CODE (template_type));
4625 CLASSTYPE_DECLARED_CLASS (t)
4626 = CLASSTYPE_DECLARED_CLASS (template_type);
4627 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
4628 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
4630 /* A local class. Make sure the decl gets registered properly. */
4631 if (context == current_function_decl)
4632 pushtag (DECL_NAME (template), t, 0);
4635 /* If we called start_enum or pushtag above, this information
4636 will already be set up. */
4639 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
4641 type_decl = create_implicit_typedef (DECL_NAME (template), t);
4642 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
4643 TYPE_STUB_DECL (t) = type_decl;
4644 DECL_SOURCE_LOCATION (type_decl)
4645 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
4648 type_decl = TYPE_NAME (t);
4650 TREE_PRIVATE (type_decl)
4651 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
4652 TREE_PROTECTED (type_decl)
4653 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
4655 /* Set up the template information. We have to figure out which
4656 template is the immediate parent if this is a full
4658 if (parm_depth == 1 || is_partial_instantiation
4659 || !PRIMARY_TEMPLATE_P (template))
4660 /* This case is easy; there are no member templates involved. */
4664 /* This is a full instantiation of a member template. Look
4665 for a partial instantiation of which this is an instance. */
4667 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
4668 found; found = TREE_CHAIN (found))
4671 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
4673 /* We only want partial instantiations, here, not
4674 specializations or full instantiations. */
4675 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
4676 || !uses_template_parms (TREE_VALUE (found)))
4679 /* Temporarily reduce by one the number of levels in the
4680 ARGLIST and in FOUND so as to avoid comparing the
4681 last set of arguments. */
4682 TREE_VEC_LENGTH (arglist)--;
4683 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
4685 /* See if the arguments match. If they do, then TMPL is
4686 the partial instantiation we want. */
4687 success = comp_template_args (TREE_PURPOSE (found), arglist);
4689 /* Restore the argument vectors to their full size. */
4690 TREE_VEC_LENGTH (arglist)++;
4691 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
4702 /* There was no partial instantiation. This happens
4703 where C<T> is a member template of A<T> and it's used
4706 template <typename T> struct B { A<T>::C<int> m; };
4709 Create the partial instantiation.
4711 TREE_VEC_LENGTH (arglist)--;
4712 found = tsubst (template, arglist, complain, NULL_TREE);
4713 TREE_VEC_LENGTH (arglist)++;
4717 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
4718 DECL_TEMPLATE_INSTANTIATIONS (template)
4719 = tree_cons (arglist, t,
4720 DECL_TEMPLATE_INSTANTIATIONS (template));
4722 if (TREE_CODE (t) == ENUMERAL_TYPE
4723 && !is_partial_instantiation)
4724 /* Now that the type has been registered on the instantiations
4725 list, we set up the enumerators. Because the enumeration
4726 constants may involve the enumeration type itself, we make
4727 sure to register the type first, and then create the
4728 constants. That way, doing tsubst_expr for the enumeration
4729 constants won't result in recursive calls here; we'll find
4730 the instantiation and exit above. */
4731 tsubst_enum (template_type, t, arglist);
4733 /* Reset the name of the type, now that CLASSTYPE_TEMPLATE_INFO
4735 if (TREE_CODE (t) != ENUMERAL_TYPE)
4736 DECL_NAME (type_decl) = classtype_mangled_name (t);
4737 if (is_partial_instantiation)
4738 /* If the type makes use of template parameters, the
4739 code that generates debugging information will crash. */
4740 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
4742 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4744 timevar_pop (TV_NAME_LOOKUP);
4751 struct pointer_set_t *visited;
4754 /* Called from for_each_template_parm via walk_tree. */
4757 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
4760 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
4761 tree_fn_t fn = pfd->fn;
4762 void *data = pfd->data;
4765 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
4766 return error_mark_node;
4768 switch (TREE_CODE (t))
4771 if (TYPE_PTRMEMFUNC_P (t))
4777 if (!TYPE_TEMPLATE_INFO (t))
4779 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
4780 fn, data, pfd->visited))
4781 return error_mark_node;
4785 /* Since we're not going to walk subtrees, we have to do this
4787 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
4789 return error_mark_node;
4793 /* Check the return type. */
4794 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4795 return error_mark_node;
4797 /* Check the parameter types. Since default arguments are not
4798 instantiated until they are needed, the TYPE_ARG_TYPES may
4799 contain expressions that involve template parameters. But,
4800 no-one should be looking at them yet. And, once they're
4801 instantiated, they don't contain template parameters, so
4802 there's no point in looking at them then, either. */
4806 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
4807 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
4809 return error_mark_node;
4811 /* Since we've already handled the TYPE_ARG_TYPES, we don't
4812 want walk_tree walking into them itself. */
4818 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
4820 return error_mark_node;
4825 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
4826 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
4828 return error_mark_node;
4833 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
4834 && for_each_template_parm (DECL_INITIAL (t), fn, data,
4836 return error_mark_node;
4837 if (DECL_CONTEXT (t)
4838 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
4840 return error_mark_node;
4843 case BOUND_TEMPLATE_TEMPLATE_PARM:
4844 /* Record template parameters such as `T' inside `TT<T>'. */
4845 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
4846 return error_mark_node;
4849 case TEMPLATE_TEMPLATE_PARM:
4850 case TEMPLATE_TYPE_PARM:
4851 case TEMPLATE_PARM_INDEX:
4852 if (fn && (*fn)(t, data))
4853 return error_mark_node;
4855 return error_mark_node;
4859 /* A template template parameter is encountered. */
4860 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
4861 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
4862 return error_mark_node;
4864 /* Already substituted template template parameter */
4870 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
4871 data, pfd->visited))
4872 return error_mark_node;
4876 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
4877 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
4878 (TREE_TYPE (t)), fn, data,
4880 return error_mark_node;
4885 /* If there's no type, then this thing must be some expression
4886 involving template parameters. */
4887 if (!fn && !TREE_TYPE (t))
4888 return error_mark_node;
4893 case REINTERPRET_CAST_EXPR:
4894 case CONST_CAST_EXPR:
4895 case STATIC_CAST_EXPR:
4896 case DYNAMIC_CAST_EXPR:
4900 case PSEUDO_DTOR_EXPR:
4902 return error_mark_node;
4906 /* If we do not handle this case specially, we end up walking
4907 the BINFO hierarchy, which is circular, and therefore
4908 confuses walk_tree. */
4910 if (for_each_template_parm (BASELINK_FUNCTIONS (*tp), fn, data,
4912 return error_mark_node;
4919 /* We didn't find any template parameters we liked. */
4923 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
4924 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
4925 call FN with the parameter and the DATA.
4926 If FN returns nonzero, the iteration is terminated, and
4927 for_each_template_parm returns 1. Otherwise, the iteration
4928 continues. If FN never returns a nonzero value, the value
4929 returned by for_each_template_parm is 0. If FN is NULL, it is
4930 considered to be the function which always returns 1. */
4933 for_each_template_parm (tree t, tree_fn_t fn, void* data,
4934 struct pointer_set_t *visited)
4936 struct pair_fn_data pfd;
4943 /* Walk the tree. (Conceptually, we would like to walk without
4944 duplicates, but for_each_template_parm_r recursively calls
4945 for_each_template_parm, so we would need to reorganize a fair
4946 bit to use walk_tree_without_duplicates, so we keep our own
4949 pfd.visited = visited;
4951 pfd.visited = pointer_set_create ();
4952 result = walk_tree (&t,
4953 for_each_template_parm_r,
4955 pfd.visited) != NULL_TREE;
4960 pointer_set_destroy (pfd.visited);
4967 /* Returns true if T depends on any template parameter. */
4970 uses_template_parms (tree t)
4973 int saved_processing_template_decl;
4975 saved_processing_template_decl = processing_template_decl;
4976 if (!saved_processing_template_decl)
4977 processing_template_decl = 1;
4979 dependent_p = dependent_type_p (t);
4980 else if (TREE_CODE (t) == TREE_VEC)
4981 dependent_p = any_dependent_template_arguments_p (t);
4982 else if (TREE_CODE (t) == TREE_LIST)
4983 dependent_p = (uses_template_parms (TREE_VALUE (t))
4984 || uses_template_parms (TREE_CHAIN (t)));
4987 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
4988 || TREE_CODE (t) == OVERLOAD
4989 || TREE_CODE (t) == BASELINK
4990 || CONSTANT_CLASS_P (t))
4991 dependent_p = (type_dependent_expression_p (t)
4992 || value_dependent_expression_p (t));
4995 gcc_assert (t == error_mark_node);
4996 dependent_p = false;
4999 processing_template_decl = saved_processing_template_decl;
5004 /* Returns true if T depends on any template parameter with level LEVEL. */
5007 uses_template_parms_level (tree t, int level)
5009 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
5012 static int tinst_depth;
5013 extern int max_tinst_depth;
5014 #ifdef GATHER_STATISTICS
5017 static int tinst_level_tick;
5018 static int last_template_error_tick;
5020 /* We're starting to instantiate D; record the template instantiation context
5021 for diagnostics and to restore it later. */
5024 push_tinst_level (tree d)
5028 if (tinst_depth >= max_tinst_depth)
5030 /* If the instantiation in question still has unbound template parms,
5031 we don't really care if we can't instantiate it, so just return.
5032 This happens with base instantiation for implicit `typename'. */
5033 if (uses_template_parms (d))
5036 last_template_error_tick = tinst_level_tick;
5037 error ("template instantiation depth exceeds maximum of %d (use "
5038 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
5039 max_tinst_depth, d);
5041 print_instantiation_context ();
5046 new = make_tinst_level (d, input_location);
5047 TREE_CHAIN (new) = current_tinst_level;
5048 current_tinst_level = new;
5051 #ifdef GATHER_STATISTICS
5052 if (tinst_depth > depth_reached)
5053 depth_reached = tinst_depth;
5060 /* We're done instantiating this template; return to the instantiation
5064 pop_tinst_level (void)
5066 tree old = current_tinst_level;
5068 /* Restore the filename and line number stashed away when we started
5069 this instantiation. */
5070 input_location = TINST_LOCATION (old);
5071 current_tinst_level = TREE_CHAIN (old);
5076 /* We're instantiating a deferred template; restore the template
5077 instantiation context in which the instantiation was requested, which
5078 is one step out from LEVEL. */
5081 reopen_tinst_level (tree level)
5086 for (t = level; t; t = TREE_CHAIN (t))
5089 current_tinst_level = level;
5093 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
5094 vector of template arguments, as for tsubst.
5096 Returns an appropriate tsubst'd friend declaration. */
5099 tsubst_friend_function (tree decl, tree args)
5103 if (TREE_CODE (decl) == FUNCTION_DECL
5104 && DECL_TEMPLATE_INSTANTIATION (decl)
5105 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
5106 /* This was a friend declared with an explicit template
5107 argument list, e.g.:
5111 to indicate that f was a template instantiation, not a new
5112 function declaration. Now, we have to figure out what
5113 instantiation of what template. */
5115 tree template_id, arglist, fns;
5118 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
5120 /* Friend functions are looked up in the containing namespace scope.
5121 We must enter that scope, to avoid finding member functions of the
5122 current cless with same name. */
5123 push_nested_namespace (ns);
5124 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
5125 tf_error | tf_warning, NULL_TREE);
5126 pop_nested_namespace (ns);
5127 arglist = tsubst (DECL_TI_ARGS (decl), args,
5128 tf_error | tf_warning, NULL_TREE);
5129 template_id = lookup_template_function (fns, arglist);
5131 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
5132 tmpl = determine_specialization (template_id, new_friend,
5134 /*need_member_template=*/0,
5135 TREE_VEC_LENGTH (args));
5136 return instantiate_template (tmpl, new_args, tf_error);
5139 new_friend = tsubst (decl, args, tf_error | tf_warning, NULL_TREE);
5141 /* The NEW_FRIEND will look like an instantiation, to the
5142 compiler, but is not an instantiation from the point of view of
5143 the language. For example, we might have had:
5145 template <class T> struct S {
5146 template <class U> friend void f(T, U);
5149 Then, in S<int>, template <class U> void f(int, U) is not an
5150 instantiation of anything. */
5151 if (new_friend == error_mark_node)
5152 return error_mark_node;
5154 DECL_USE_TEMPLATE (new_friend) = 0;
5155 if (TREE_CODE (decl) == TEMPLATE_DECL)
5157 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
5158 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
5159 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
5162 /* The mangled name for the NEW_FRIEND is incorrect. The function
5163 is not a template instantiation and should not be mangled like
5164 one. Therefore, we forget the mangling here; we'll recompute it
5165 later if we need it. */
5166 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
5168 SET_DECL_RTL (new_friend, NULL_RTX);
5169 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
5172 if (DECL_NAMESPACE_SCOPE_P (new_friend))
5175 tree new_friend_template_info;
5176 tree new_friend_result_template_info;
5178 int new_friend_is_defn;
5180 /* We must save some information from NEW_FRIEND before calling
5181 duplicate decls since that function will free NEW_FRIEND if
5183 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
5184 new_friend_is_defn =
5185 (DECL_INITIAL (DECL_TEMPLATE_RESULT
5186 (template_for_substitution (new_friend)))
5188 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
5190 /* This declaration is a `primary' template. */
5191 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
5193 new_friend_result_template_info
5194 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
5197 new_friend_result_template_info = NULL_TREE;
5199 /* Inside pushdecl_namespace_level, we will push into the
5200 current namespace. However, the friend function should go
5201 into the namespace of the template. */
5202 ns = decl_namespace_context (new_friend);
5203 push_nested_namespace (ns);
5204 old_decl = pushdecl_namespace_level (new_friend);
5205 pop_nested_namespace (ns);
5207 if (old_decl != new_friend)
5209 /* This new friend declaration matched an existing
5210 declaration. For example, given:
5212 template <class T> void f(T);
5213 template <class U> class C {
5214 template <class T> friend void f(T) {}
5217 the friend declaration actually provides the definition
5218 of `f', once C has been instantiated for some type. So,
5219 old_decl will be the out-of-class template declaration,
5220 while new_friend is the in-class definition.
5222 But, if `f' was called before this point, the
5223 instantiation of `f' will have DECL_TI_ARGS corresponding
5224 to `T' but not to `U', references to which might appear
5225 in the definition of `f'. Previously, the most general
5226 template for an instantiation of `f' was the out-of-class
5227 version; now it is the in-class version. Therefore, we
5228 run through all specialization of `f', adding to their
5229 DECL_TI_ARGS appropriately. In particular, they need a
5230 new set of outer arguments, corresponding to the
5231 arguments for this class instantiation.
5233 The same situation can arise with something like this:
5236 template <class T> class C {
5240 when `C<int>' is instantiated. Now, `f(int)' is defined
5243 if (!new_friend_is_defn)
5244 /* On the other hand, if the in-class declaration does
5245 *not* provide a definition, then we don't want to alter
5246 existing definitions. We can just leave everything
5251 /* Overwrite whatever template info was there before, if
5252 any, with the new template information pertaining to
5254 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
5256 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
5257 reregister_specialization (new_friend,
5258 most_general_template (old_decl),
5263 tree new_friend_args;
5265 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
5266 = new_friend_result_template_info;
5268 new_friend_args = TI_ARGS (new_friend_template_info);
5269 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
5273 tree spec = TREE_VALUE (t);
5276 = add_outermost_template_args (new_friend_args,
5277 DECL_TI_ARGS (spec));
5280 /* Now, since specializations are always supposed to
5281 hang off of the most general template, we must move
5283 t = most_general_template (old_decl);
5286 DECL_TEMPLATE_SPECIALIZATIONS (t)
5287 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
5288 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
5289 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
5294 /* The information from NEW_FRIEND has been merged into OLD_DECL
5295 by duplicate_decls. */
5296 new_friend = old_decl;
5301 tree context = DECL_CONTEXT (new_friend);
5305 template <class T> class C {
5306 template <class U> friend void C1<U>::f (); // case 1
5307 friend void C2<T>::f (); // case 2
5309 we only need to make sure CONTEXT is a complete type for
5310 case 2. To distinguish between the two cases, we note that
5311 CONTEXT of case 1 remains dependent type after tsubst while
5312 this isn't true for case 2. */
5313 ++processing_template_decl;
5314 dependent_p = dependent_type_p (context);
5315 --processing_template_decl;
5318 && !complete_type_or_else (context, NULL_TREE))
5319 return error_mark_node;
5321 if (COMPLETE_TYPE_P (context))
5323 /* Check to see that the declaration is really present, and,
5324 possibly obtain an improved declaration. */
5325 tree fn = check_classfn (context,
5326 new_friend, NULL_TREE);
5336 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
5337 template arguments, as for tsubst.
5339 Returns an appropriate tsubst'd friend type or error_mark_node on
5343 tsubst_friend_class (tree friend_tmpl, tree args)
5349 context = DECL_CONTEXT (friend_tmpl);
5353 if (TREE_CODE (context) == NAMESPACE_DECL)
5354 push_nested_namespace (context);
5356 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
5359 /* First, we look for a class template. */
5360 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/0);
5362 /* But, if we don't find one, it might be because we're in a
5363 situation like this:
5371 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5372 for `S<int>', not the TEMPLATE_DECL. */
5373 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5375 tmpl = lookup_name (DECL_NAME (friend_tmpl), /*prefer_type=*/1);
5376 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
5379 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
5381 /* The friend template has already been declared. Just
5382 check to see that the declarations match, and install any new
5383 default parameters. We must tsubst the default parameters,
5384 of course. We only need the innermost template parameters
5385 because that is all that redeclare_class_template will look
5387 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
5388 > TMPL_ARGS_DEPTH (args))
5391 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
5392 args, tf_error | tf_warning);
5393 redeclare_class_template (TREE_TYPE (tmpl), parms);
5396 friend_type = TREE_TYPE (tmpl);
5400 /* The friend template has not already been declared. In this
5401 case, the instantiation of the template class will cause the
5402 injection of this template into the global scope. */
5403 tmpl = tsubst (friend_tmpl, args, tf_error | tf_warning, NULL_TREE);
5405 /* The new TMPL is not an instantiation of anything, so we
5406 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
5407 the new type because that is supposed to be the corresponding
5408 template decl, i.e., TMPL. */
5409 DECL_USE_TEMPLATE (tmpl) = 0;
5410 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
5411 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
5412 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
5413 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
5415 /* Inject this template into the global scope. */
5416 friend_type = TREE_TYPE (pushdecl_top_level (tmpl));
5421 if (TREE_CODE (context) == NAMESPACE_DECL)
5422 pop_nested_namespace (context);
5424 pop_nested_class ();
5430 /* Returns zero if TYPE cannot be completed later due to circularity.
5431 Otherwise returns one. */
5434 can_complete_type_without_circularity (tree type)
5436 if (type == NULL_TREE || type == error_mark_node)
5438 else if (COMPLETE_TYPE_P (type))
5440 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
5441 return can_complete_type_without_circularity (TREE_TYPE (type));
5442 else if (CLASS_TYPE_P (type)
5443 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
5450 instantiate_class_template (tree type)
5452 tree template, args, pattern, t, member;
5457 if (type == error_mark_node)
5458 return error_mark_node;
5460 if (TYPE_BEING_DEFINED (type)
5461 || COMPLETE_TYPE_P (type)
5462 || dependent_type_p (type))
5465 /* Figure out which template is being instantiated. */
5466 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
5467 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
5469 /* Figure out which arguments are being used to do the
5471 args = CLASSTYPE_TI_ARGS (type);
5473 /* Determine what specialization of the original template to
5475 t = most_specialized_class (template, args);
5476 if (t == error_mark_node)
5478 const char *str = "candidates are:";
5479 error ("ambiguous class template instantiation for %q#T", type);
5480 for (t = DECL_TEMPLATE_SPECIALIZATIONS (template); t;
5483 if (get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args))
5485 cp_error_at ("%s %+#T", str, TREE_TYPE (t));
5489 TYPE_BEING_DEFINED (type) = 1;
5490 return error_mark_node;
5494 pattern = TREE_TYPE (t);
5496 pattern = TREE_TYPE (template);
5498 /* If the template we're instantiating is incomplete, then clearly
5499 there's nothing we can do. */
5500 if (!COMPLETE_TYPE_P (pattern))
5503 /* If we've recursively instantiated too many templates, stop. */
5504 if (! push_tinst_level (type))
5507 /* Now we're really doing the instantiation. Mark the type as in
5508 the process of being defined. */
5509 TYPE_BEING_DEFINED (type) = 1;
5511 /* We may be in the middle of deferred access check. Disable
5513 push_deferring_access_checks (dk_no_deferred);
5515 push_to_top_level ();
5519 /* This TYPE is actually an instantiation of a partial
5520 specialization. We replace the innermost set of ARGS with
5521 the arguments appropriate for substitution. For example,
5524 template <class T> struct S {};
5525 template <class T> struct S<T*> {};
5527 and supposing that we are instantiating S<int*>, ARGS will
5528 present be {int*} but we need {int}. */
5530 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t),
5533 /* If there were multiple levels in ARGS, replacing the
5534 innermost level would alter CLASSTYPE_TI_ARGS, which we don't
5535 want, so we make a copy first. */
5536 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
5538 args = copy_node (args);
5539 SET_TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args), inner_args);
5545 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
5547 /* Set the input location to the template definition. This is needed
5548 if tsubsting causes an error. */
5549 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (pattern));
5551 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
5552 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
5553 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
5554 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
5555 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
5556 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
5557 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
5558 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
5559 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
5560 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
5561 TYPE_PACKED (type) = TYPE_PACKED (pattern);
5562 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
5563 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
5564 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
5565 if (ANON_AGGR_TYPE_P (pattern))
5566 SET_ANON_AGGR_TYPE_P (type);
5568 pbinfo = TYPE_BINFO (pattern);
5570 /* We should never instantiate a nested class before its enclosing
5571 class; we need to look up the nested class by name before we can
5572 instantiate it, and that lookup should instantiate the enclosing
5574 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
5575 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
5576 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
5578 base_list = NULL_TREE;
5579 if (BINFO_N_BASE_BINFOS (pbinfo))
5582 tree context = TYPE_CONTEXT (type);
5586 /* We must enter the scope containing the type, as that is where
5587 the accessibility of types named in dependent bases are
5589 pushed_scope = push_scope (context ? context : global_namespace);
5591 /* Substitute into each of the bases to determine the actual
5593 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
5596 tree access = BINFO_BASE_ACCESS (pbinfo, i);
5598 /* Substitute to figure out the base class. */
5599 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error, NULL_TREE);
5600 if (base == error_mark_node)
5603 base_list = tree_cons (access, base, base_list);
5604 if (BINFO_VIRTUAL_P (pbase_binfo))
5605 TREE_TYPE (base_list) = integer_type_node;
5608 /* The list is now in reverse order; correct that. */
5609 base_list = nreverse (base_list);
5612 pop_scope (pushed_scope);
5614 /* Now call xref_basetypes to set up all the base-class
5616 xref_basetypes (type, base_list);
5619 /* Now that our base classes are set up, enter the scope of the
5620 class, so that name lookups into base classes, etc. will work
5621 correctly. This is precisely analogous to what we do in
5622 begin_class_definition when defining an ordinary non-template
5626 /* Now members are processed in the order of declaration. */
5627 for (member = CLASSTYPE_DECL_LIST (pattern);
5628 member; member = TREE_CHAIN (member))
5630 tree t = TREE_VALUE (member);
5632 if (TREE_PURPOSE (member))
5636 /* Build new CLASSTYPE_NESTED_UTDS. */
5639 tree name = TYPE_IDENTIFIER (tag);
5641 bool class_template_p;
5643 class_template_p = (TREE_CODE (tag) != ENUMERAL_TYPE
5644 && TYPE_LANG_SPECIFIC (tag)
5645 && CLASSTYPE_IS_TEMPLATE (tag));
5646 /* If the member is a class template, then -- even after
5647 substitution -- there may be dependent types in the
5648 template argument list for the class. We increment
5649 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
5650 that function will assume that no types are dependent
5651 when outside of a template. */
5652 if (class_template_p)
5653 ++processing_template_decl;
5654 newtag = tsubst (tag, args, tf_error, NULL_TREE);
5655 if (class_template_p)
5656 --processing_template_decl;
5657 if (newtag == error_mark_node)
5660 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
5662 if (class_template_p)
5663 /* Unfortunately, lookup_template_class sets
5664 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
5665 instantiation (i.e., for the type of a member
5666 template class nested within a template class.)
5667 This behavior is required for
5668 maybe_process_partial_specialization to work
5669 correctly, but is not accurate in this case;
5670 the TAG is not an instantiation of anything.
5671 (The corresponding TEMPLATE_DECL is an
5672 instantiation, but the TYPE is not.) */
5673 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
5675 /* Now, we call pushtag to put this NEWTAG into the scope of
5676 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
5677 pushtag calling push_template_decl. We don't have to do
5678 this for enums because it will already have been done in
5681 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
5682 pushtag (name, newtag, /*globalize=*/0);
5685 else if (TREE_CODE (t) == FUNCTION_DECL
5686 || DECL_FUNCTION_TEMPLATE_P (t))
5688 /* Build new TYPE_METHODS. */
5691 if (TREE_CODE (t) == TEMPLATE_DECL)
5692 ++processing_template_decl;
5693 r = tsubst (t, args, tf_error, NULL_TREE);
5694 if (TREE_CODE (t) == TEMPLATE_DECL)
5695 --processing_template_decl;
5696 set_current_access_from_decl (r);
5697 grok_special_member_properties (r);
5698 finish_member_declaration (r);
5702 /* Build new TYPE_FIELDS. */
5704 if (TREE_CODE (t) != CONST_DECL)
5708 /* The the file and line for this declaration, to
5709 assist in error message reporting. Since we
5710 called push_tinst_level above, we don't need to
5712 input_location = DECL_SOURCE_LOCATION (t);
5714 if (TREE_CODE (t) == TEMPLATE_DECL)
5715 ++processing_template_decl;
5716 r = tsubst (t, args, tf_error | tf_warning, NULL_TREE);
5717 if (TREE_CODE (t) == TEMPLATE_DECL)
5718 --processing_template_decl;
5719 if (TREE_CODE (r) == VAR_DECL)
5723 if (DECL_INITIALIZED_IN_CLASS_P (r))
5724 init = tsubst_expr (DECL_INITIAL (t), args,
5725 tf_error | tf_warning, NULL_TREE);
5729 finish_static_data_member_decl
5730 (r, init, /*asmspec_tree=*/NULL_TREE, /*flags=*/0);
5732 if (DECL_INITIALIZED_IN_CLASS_P (r))
5733 check_static_variable_definition (r, TREE_TYPE (r));
5735 else if (TREE_CODE (r) == FIELD_DECL)
5737 /* Determine whether R has a valid type and can be
5738 completed later. If R is invalid, then it is
5739 replaced by error_mark_node so that it will not be
5740 added to TYPE_FIELDS. */
5741 tree rtype = TREE_TYPE (r);
5742 if (can_complete_type_without_circularity (rtype))
5743 complete_type (rtype);
5745 if (!COMPLETE_TYPE_P (rtype))
5747 cxx_incomplete_type_error (r, rtype);
5748 r = error_mark_node;
5752 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
5753 such a thing will already have been added to the field
5754 list by tsubst_enum in finish_member_declaration in the
5755 CLASSTYPE_NESTED_UTDS case above. */
5756 if (!(TREE_CODE (r) == TYPE_DECL
5757 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
5758 && DECL_ARTIFICIAL (r)))
5760 set_current_access_from_decl (r);
5761 finish_member_declaration (r);
5768 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
5770 /* Build new CLASSTYPE_FRIEND_CLASSES. */
5772 tree friend_type = t;
5773 bool adjust_processing_template_decl = false;
5775 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5777 friend_type = tsubst_friend_class (friend_type, args);
5778 adjust_processing_template_decl = true;
5780 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
5782 friend_type = tsubst (friend_type, args,
5783 tf_error | tf_warning, NULL_TREE);
5784 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
5785 friend_type = TREE_TYPE (friend_type);
5786 adjust_processing_template_decl = true;
5788 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
5790 friend_type = tsubst (friend_type, args,
5791 tf_error | tf_warning, NULL_TREE);
5792 /* Bump processing_template_decl for correct
5793 dependent_type_p calculation. */
5794 ++processing_template_decl;
5795 if (dependent_type_p (friend_type))
5796 adjust_processing_template_decl = true;
5797 --processing_template_decl;
5799 else if (uses_template_parms (friend_type))
5800 friend_type = tsubst (friend_type, args,
5801 tf_error | tf_warning, NULL_TREE);
5802 else if (CLASSTYPE_USE_TEMPLATE (friend_type))
5803 friend_type = friend_type;
5806 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
5808 /* The call to xref_tag_from_type does injection for friend
5810 push_nested_namespace (ns);
5812 xref_tag_from_type (friend_type, NULL_TREE,
5813 /*tag_scope=*/ts_global);
5814 pop_nested_namespace (ns);
5817 if (adjust_processing_template_decl)
5818 /* Trick make_friend_class into realizing that the friend
5819 we're adding is a template, not an ordinary class. It's
5820 important that we use make_friend_class since it will
5821 perform some error-checking and output cross-reference
5823 ++processing_template_decl;
5825 if (friend_type != error_mark_node)
5826 make_friend_class (type, friend_type, /*complain=*/false);
5828 if (adjust_processing_template_decl)
5829 --processing_template_decl;
5833 /* Build new DECL_FRIENDLIST. */
5836 /* The the file and line for this declaration, to
5837 assist in error message reporting. Since we
5838 called push_tinst_level above, we don't need to
5840 input_location = DECL_SOURCE_LOCATION (t);
5842 if (TREE_CODE (t) == TEMPLATE_DECL)
5844 ++processing_template_decl;
5845 push_deferring_access_checks (dk_no_check);
5848 r = tsubst_friend_function (t, args);
5849 add_friend (type, r, /*complain=*/false);
5850 if (TREE_CODE (t) == TEMPLATE_DECL)
5852 pop_deferring_access_checks ();
5853 --processing_template_decl;
5859 /* Set the file and line number information to whatever is given for
5860 the class itself. This puts error messages involving generated
5861 implicit functions at a predictable point, and the same point
5862 that would be used for non-template classes. */
5863 typedecl = TYPE_MAIN_DECL (type);
5864 input_location = DECL_SOURCE_LOCATION (typedecl);
5866 unreverse_member_declarations (type);
5867 finish_struct_1 (type);
5868 TYPE_BEING_DEFINED (type) = 0;
5870 /* Now that the class is complete, instantiate default arguments for
5871 any member functions. We don't do this earlier because the
5872 default arguments may reference members of the class. */
5873 if (!PRIMARY_TEMPLATE_P (template))
5874 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
5875 if (TREE_CODE (t) == FUNCTION_DECL
5876 /* Implicitly generated member functions will not have template
5877 information; they are not instantiations, but instead are
5878 created "fresh" for each instantiation. */
5879 && DECL_TEMPLATE_INFO (t))
5880 tsubst_default_arguments (t);
5883 pop_from_top_level ();
5884 pop_deferring_access_checks ();
5887 /* The vtable for a template class can be emitted in any translation
5888 unit in which the class is instantiated. When there is no key
5889 method, however, finish_struct_1 will already have added TYPE to
5890 the keyed_classes list. */
5891 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
5892 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
5898 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
5904 else if (TYPE_P (t))
5905 r = tsubst (t, args, complain, in_decl);
5908 r = tsubst_expr (t, args, complain, in_decl);
5910 if (!uses_template_parms (r))
5912 /* Sometimes, one of the args was an expression involving a
5913 template constant parameter, like N - 1. Now that we've
5914 tsubst'd, we might have something like 2 - 1. This will
5915 confuse lookup_template_class, so we do constant folding
5916 here. We have to unset processing_template_decl, to fool
5917 tsubst_copy_and_build() into building an actual tree. */
5919 /* If the TREE_TYPE of ARG is not NULL_TREE, ARG is already
5920 as simple as it's going to get, and trying to reprocess
5921 the trees will break. Once tsubst_expr et al DTRT for
5922 non-dependent exprs, this code can go away, as the type
5923 will always be set. */
5926 int saved_processing_template_decl = processing_template_decl;
5927 processing_template_decl = 0;
5928 r = tsubst_copy_and_build (r, /*args=*/NULL_TREE,
5929 tf_error, /*in_decl=*/NULL_TREE,
5930 /*function_p=*/false);
5931 processing_template_decl = saved_processing_template_decl;
5939 /* Substitute ARGS into the vector or list of template arguments T. */
5942 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
5944 int len = TREE_VEC_LENGTH (t);
5945 int need_new = 0, i;
5946 tree *elts = alloca (len * sizeof (tree));
5948 for (i = 0; i < len; i++)
5950 tree orig_arg = TREE_VEC_ELT (t, i);
5953 if (TREE_CODE (orig_arg) == TREE_VEC)
5954 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
5956 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
5958 if (new_arg == error_mark_node)
5959 return error_mark_node;
5962 if (new_arg != orig_arg)
5969 t = make_tree_vec (len);
5970 for (i = 0; i < len; i++)
5971 TREE_VEC_ELT (t, i) = elts[i];
5976 /* Return the result of substituting ARGS into the template parameters
5977 given by PARMS. If there are m levels of ARGS and m + n levels of
5978 PARMS, then the result will contain n levels of PARMS. For
5979 example, if PARMS is `template <class T> template <class U>
5980 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
5981 result will be `template <int*, double, class V>'. */
5984 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
5989 for (new_parms = &r;
5990 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
5991 new_parms = &(TREE_CHAIN (*new_parms)),
5992 parms = TREE_CHAIN (parms))
5995 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
5998 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
6000 tree tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
6001 tree default_value = TREE_PURPOSE (tuple);
6002 tree parm_decl = TREE_VALUE (tuple);
6004 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
6005 default_value = tsubst_template_arg (default_value, args,
6006 complain, NULL_TREE);
6008 tuple = build_tree_list (default_value, parm_decl);
6009 TREE_VEC_ELT (new_vec, i) = tuple;
6013 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
6014 - TMPL_ARGS_DEPTH (args)),
6015 new_vec, NULL_TREE);
6021 /* Substitute the ARGS into the indicated aggregate (or enumeration)
6022 type T. If T is not an aggregate or enumeration type, it is
6023 handled as if by tsubst. IN_DECL is as for tsubst. If
6024 ENTERING_SCOPE is nonzero, T is the context for a template which
6025 we are presently tsubst'ing. Return the substituted value. */
6028 tsubst_aggr_type (tree t,
6030 tsubst_flags_t complain,
6037 switch (TREE_CODE (t))
6040 if (TYPE_PTRMEMFUNC_P (t))
6041 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
6043 /* Else fall through. */
6046 if (TYPE_TEMPLATE_INFO (t))
6052 /* First, determine the context for the type we are looking
6054 context = TYPE_CONTEXT (t);
6056 context = tsubst_aggr_type (context, args, complain,
6057 in_decl, /*entering_scope=*/1);
6059 /* Then, figure out what arguments are appropriate for the
6060 type we are trying to find. For example, given:
6062 template <class T> struct S;
6063 template <class T, class U> void f(T, U) { S<U> su; }
6065 and supposing that we are instantiating f<int, double>,
6066 then our ARGS will be {int, double}, but, when looking up
6067 S we only want {double}. */
6068 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
6070 if (argvec == error_mark_node)
6071 return error_mark_node;
6073 r = lookup_template_class (t, argvec, in_decl, context,
6074 entering_scope, complain);
6076 return cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
6079 /* This is not a template type, so there's nothing to do. */
6083 return tsubst (t, args, complain, in_decl);
6087 /* Substitute into the default argument ARG (a default argument for
6088 FN), which has the indicated TYPE. */
6091 tsubst_default_argument (tree fn, tree type, tree arg)
6093 tree saved_class_ptr = NULL_TREE;
6094 tree saved_class_ref = NULL_TREE;
6096 /* This default argument came from a template. Instantiate the
6097 default argument here, not in tsubst. In the case of
6106 we must be careful to do name lookup in the scope of S<T>,
6107 rather than in the current class. */
6108 push_access_scope (fn);
6109 /* The default argument expression should not be considered to be
6110 within the scope of FN. Since push_access_scope sets
6111 current_function_decl, we must explicitly clear it here. */
6112 current_function_decl = NULL_TREE;
6113 /* The "this" pointer is not valid in a default argument. */
6116 saved_class_ptr = current_class_ptr;
6117 cp_function_chain->x_current_class_ptr = NULL_TREE;
6118 saved_class_ref = current_class_ref;
6119 cp_function_chain->x_current_class_ref = NULL_TREE;
6122 push_deferring_access_checks(dk_no_deferred);
6123 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
6124 tf_error | tf_warning, NULL_TREE);
6125 pop_deferring_access_checks();
6127 /* Restore the "this" pointer. */
6130 cp_function_chain->x_current_class_ptr = saved_class_ptr;
6131 cp_function_chain->x_current_class_ref = saved_class_ref;
6134 pop_access_scope (fn);
6136 /* Make sure the default argument is reasonable. */
6137 arg = check_default_argument (type, arg);
6142 /* Substitute into all the default arguments for FN. */
6145 tsubst_default_arguments (tree fn)
6150 tmpl_args = DECL_TI_ARGS (fn);
6152 /* If this function is not yet instantiated, we certainly don't need
6153 its default arguments. */
6154 if (uses_template_parms (tmpl_args))
6157 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
6159 arg = TREE_CHAIN (arg))
6160 if (TREE_PURPOSE (arg))
6161 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
6163 TREE_PURPOSE (arg));
6166 /* Substitute the ARGS into the T, which is a _DECL. Return the
6167 result of the substitution. Issue error and warning messages under
6168 control of COMPLAIN. */
6171 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
6173 location_t saved_loc;
6177 /* Set the filename and linenumber to improve error-reporting. */
6178 saved_loc = input_location;
6179 input_location = DECL_SOURCE_LOCATION (t);
6181 switch (TREE_CODE (t))
6185 /* We can get here when processing a member function template,
6186 member class template, and template template parameter of
6187 a template class. */
6188 tree decl = DECL_TEMPLATE_RESULT (t);
6193 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
6195 /* Template template parameter is treated here. */
6196 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6197 if (new_type == error_mark_node)
6198 return error_mark_node;
6201 TREE_CHAIN (r) = NULL_TREE;
6202 TREE_TYPE (r) = new_type;
6203 DECL_TEMPLATE_RESULT (r)
6204 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
6205 DECL_TEMPLATE_PARMS (r)
6206 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6208 TYPE_NAME (new_type) = r;
6212 /* We might already have an instance of this template.
6213 The ARGS are for the surrounding class type, so the
6214 full args contain the tsubst'd args for the context,
6215 plus the innermost args from the template decl. */
6216 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
6217 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
6218 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
6219 full_args = tsubst_template_args (tmpl_args, args,
6222 /* tsubst_template_args doesn't copy the vector if
6223 nothing changed. But, *something* should have
6225 gcc_assert (full_args != tmpl_args);
6227 spec = retrieve_specialization (t, full_args,
6228 /*class_specializations_p=*/true);
6229 if (spec != NULL_TREE)
6235 /* Make a new template decl. It will be similar to the
6236 original, but will record the current template arguments.
6237 We also create a new function declaration, which is just
6238 like the old one, but points to this new template, rather
6239 than the old one. */
6241 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
6242 TREE_CHAIN (r) = NULL_TREE;
6245 = tsubst_aggr_type (DECL_CONTEXT (t), args,
6247 /*entering_scope=*/1);
6248 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
6250 if (TREE_CODE (decl) == TYPE_DECL)
6252 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6253 if (new_type == error_mark_node)
6254 return error_mark_node;
6256 TREE_TYPE (r) = new_type;
6257 CLASSTYPE_TI_TEMPLATE (new_type) = r;
6258 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
6259 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
6263 tree new_decl = tsubst (decl, args, complain, in_decl);
6264 if (new_decl == error_mark_node)
6265 return error_mark_node;
6267 DECL_TEMPLATE_RESULT (r) = new_decl;
6268 DECL_TI_TEMPLATE (new_decl) = r;
6269 TREE_TYPE (r) = TREE_TYPE (new_decl);
6270 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
6273 SET_DECL_IMPLICIT_INSTANTIATION (r);
6274 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
6275 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
6277 /* The template parameters for this new template are all the
6278 template parameters for the old template, except the
6279 outermost level of parameters. */
6280 DECL_TEMPLATE_PARMS (r)
6281 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
6284 if (PRIMARY_TEMPLATE_P (t))
6285 DECL_PRIMARY_TEMPLATE (r) = r;
6287 if (TREE_CODE (decl) != TYPE_DECL)
6288 /* Record this non-type partial instantiation. */
6289 register_specialization (r, t,
6290 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)));
6297 tree argvec = NULL_TREE;
6305 /* Nobody should be tsubst'ing into non-template functions. */
6306 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
6308 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
6313 /* If T is not dependent, just return it. We have to
6314 increment PROCESSING_TEMPLATE_DECL because
6315 value_dependent_expression_p assumes that nothing is
6316 dependent when PROCESSING_TEMPLATE_DECL is zero. */
6317 ++processing_template_decl;
6318 dependent_p = value_dependent_expression_p (t);
6319 --processing_template_decl;
6323 /* Calculate the most general template of which R is a
6324 specialization, and the complete set of arguments used to
6326 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
6327 argvec = tsubst_template_args (DECL_TI_ARGS
6328 (DECL_TEMPLATE_RESULT (gen_tmpl)),
6329 args, complain, in_decl);
6331 /* Check to see if we already have this specialization. */
6332 spec = retrieve_specialization (gen_tmpl, argvec,
6333 /*class_specializations_p=*/false);
6341 /* We can see more levels of arguments than parameters if
6342 there was a specialization of a member template, like
6345 template <class T> struct S { template <class U> void f(); }
6346 template <> template <class U> void S<int>::f(U);
6348 Here, we'll be substituting into the specialization,
6349 because that's where we can find the code we actually
6350 want to generate, but we'll have enough arguments for
6351 the most general template.
6353 We also deal with the peculiar case:
6355 template <class T> struct S {
6356 template <class U> friend void f();
6358 template <class U> void f() {}
6360 template void f<double>();
6362 Here, the ARGS for the instantiation of will be {int,
6363 double}. But, we only need as many ARGS as there are
6364 levels of template parameters in CODE_PATTERN. We are
6365 careful not to get fooled into reducing the ARGS in
6368 template <class T> struct S { template <class U> void f(U); }
6369 template <class T> template <> void S<T>::f(int) {}
6371 which we can spot because the pattern will be a
6372 specialization in this case. */
6373 args_depth = TMPL_ARGS_DEPTH (args);
6375 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
6376 if (args_depth > parms_depth
6377 && !DECL_TEMPLATE_SPECIALIZATION (t))
6378 args = get_innermost_template_args (args, parms_depth);
6382 /* This special case arises when we have something like this:
6384 template <class T> struct S {
6385 friend void f<int>(int, double);
6388 Here, the DECL_TI_TEMPLATE for the friend declaration
6389 will be an IDENTIFIER_NODE. We are being called from
6390 tsubst_friend_function, and we want only to create a
6391 new decl (R) with appropriate types so that we can call
6392 determine_specialization. */
6393 gen_tmpl = NULL_TREE;
6396 if (DECL_CLASS_SCOPE_P (t))
6398 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
6402 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6403 complain, t, /*entering_scope=*/1);
6408 ctx = DECL_CONTEXT (t);
6410 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6411 if (type == error_mark_node)
6412 return error_mark_node;
6414 /* We do NOT check for matching decls pushed separately at this
6415 point, as they may not represent instantiations of this
6416 template, and in any case are considered separate under the
6419 DECL_USE_TEMPLATE (r) = 0;
6420 TREE_TYPE (r) = type;
6421 /* Clear out the mangled name and RTL for the instantiation. */
6422 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6423 SET_DECL_RTL (r, NULL_RTX);
6424 DECL_INITIAL (r) = NULL_TREE;
6425 DECL_CONTEXT (r) = ctx;
6427 if (member && DECL_CONV_FN_P (r))
6428 /* Type-conversion operator. Reconstruct the name, in
6429 case it's the name of one of the template's parameters. */
6430 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
6432 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
6434 DECL_RESULT (r) = NULL_TREE;
6436 TREE_STATIC (r) = 0;
6437 TREE_PUBLIC (r) = TREE_PUBLIC (t);
6438 DECL_EXTERNAL (r) = 1;
6439 /* If this is an instantiation of a function with internal
6440 linkage, we already know what object file linkage will be
6441 assigned to the instantiation. */
6442 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
6443 DECL_DEFER_OUTPUT (r) = 0;
6444 TREE_CHAIN (r) = NULL_TREE;
6445 DECL_PENDING_INLINE_INFO (r) = 0;
6446 DECL_PENDING_INLINE_P (r) = 0;
6447 DECL_SAVED_TREE (r) = NULL_TREE;
6449 if (DECL_CLONED_FUNCTION (r))
6451 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
6453 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
6454 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
6457 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
6458 this in the special friend case mentioned above where
6459 GEN_TMPL is NULL. */
6462 DECL_TEMPLATE_INFO (r)
6463 = tree_cons (gen_tmpl, argvec, NULL_TREE);
6464 SET_DECL_IMPLICIT_INSTANTIATION (r);
6465 register_specialization (r, gen_tmpl, argvec);
6467 /* We're not supposed to instantiate default arguments
6468 until they are called, for a template. But, for a
6471 template <class T> void f ()
6472 { extern void g(int i = T()); }
6474 we should do the substitution when the template is
6475 instantiated. We handle the member function case in
6476 instantiate_class_template since the default arguments
6477 might refer to other members of the class. */
6479 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6480 && !uses_template_parms (argvec))
6481 tsubst_default_arguments (r);
6484 /* Copy the list of befriending classes. */
6485 for (friends = &DECL_BEFRIENDING_CLASSES (r);
6487 friends = &TREE_CHAIN (*friends))
6489 *friends = copy_node (*friends);
6490 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
6495 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
6497 maybe_retrofit_in_chrg (r);
6498 if (DECL_CONSTRUCTOR_P (r))
6499 grok_ctor_properties (ctx, r);
6500 /* If this is an instantiation of a member template, clone it.
6501 If it isn't, that'll be handled by
6502 clone_constructors_and_destructors. */
6503 if (PRIMARY_TEMPLATE_P (gen_tmpl))
6504 clone_function_decl (r, /*update_method_vec_p=*/0);
6506 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r)))
6507 grok_op_properties (r, DECL_FRIEND_P (r),
6508 (complain & tf_error) != 0);
6510 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
6511 SET_DECL_FRIEND_CONTEXT (r,
6512 tsubst (DECL_FRIEND_CONTEXT (t),
6513 args, complain, in_decl));
6522 if (DECL_TEMPLATE_PARM_P (t))
6523 SET_DECL_TEMPLATE_PARM_P (r);
6525 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6526 type = type_decays_to (type);
6527 TREE_TYPE (r) = type;
6528 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6530 if (DECL_INITIAL (r))
6532 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
6533 DECL_INITIAL (r) = TREE_TYPE (r);
6535 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
6539 DECL_CONTEXT (r) = NULL_TREE;
6541 if (!DECL_TEMPLATE_PARM_P (r))
6542 DECL_ARG_TYPE (r) = type_passed_as (type);
6544 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
6545 complain, TREE_CHAIN (t));
6554 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6555 if (type == error_mark_node)
6556 return error_mark_node;
6557 TREE_TYPE (r) = type;
6558 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6560 /* We don't have to set DECL_CONTEXT here; it is set by
6561 finish_member_declaration. */
6562 DECL_INITIAL (r) = tsubst_expr (DECL_INITIAL (t), args,
6564 TREE_CHAIN (r) = NULL_TREE;
6565 if (VOID_TYPE_P (type))
6566 cp_error_at ("instantiation of %qD as type %qT", r, type);
6573 /* It is not a dependent using decl any more. */
6574 TREE_TYPE (r) = void_type_node;
6576 = tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
6578 = tsubst_copy (DECL_NAME (t), args, complain, in_decl);
6579 TREE_CHAIN (r) = NULL_TREE;
6586 tree argvec = NULL_TREE;
6587 tree gen_tmpl = NULL_TREE;
6589 tree tmpl = NULL_TREE;
6591 tree type = NULL_TREE;
6594 if (TREE_CODE (t) == TYPE_DECL)
6596 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6597 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
6598 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
6600 /* If this is the canonical decl, we don't have to
6601 mess with instantiations, and often we can't (for
6602 typename, template type parms and such). Note that
6603 TYPE_NAME is not correct for the above test if
6604 we've copied the type for a typedef. */
6605 r = TYPE_NAME (type);
6610 /* Assume this is a non-local variable. */
6613 if (TYPE_P (CP_DECL_CONTEXT (t)))
6614 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
6616 in_decl, /*entering_scope=*/1);
6617 else if (DECL_NAMESPACE_SCOPE_P (t))
6618 ctx = DECL_CONTEXT (t);
6621 /* Subsequent calls to pushdecl will fill this in. */
6626 /* Check to see if we already have this specialization. */
6629 tmpl = DECL_TI_TEMPLATE (t);
6630 gen_tmpl = most_general_template (tmpl);
6631 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
6632 spec = retrieve_specialization (gen_tmpl, argvec,
6633 /*class_specializations_p=*/false);
6636 spec = retrieve_local_specialization (t);
6645 if (TREE_CODE (r) == VAR_DECL)
6647 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6648 if (type == error_mark_node)
6649 return error_mark_node;
6650 type = complete_type (type);
6651 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
6652 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
6653 type = check_var_type (DECL_NAME (r), type);
6655 else if (DECL_SELF_REFERENCE_P (t))
6656 SET_DECL_SELF_REFERENCE_P (r);
6657 TREE_TYPE (r) = type;
6658 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
6659 DECL_CONTEXT (r) = ctx;
6660 /* Clear out the mangled name and RTL for the instantiation. */
6661 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
6662 SET_DECL_RTL (r, NULL_RTX);
6664 /* Don't try to expand the initializer until someone tries to use
6665 this variable; otherwise we run into circular dependencies. */
6666 DECL_INITIAL (r) = NULL_TREE;
6667 SET_DECL_RTL (r, NULL_RTX);
6668 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
6670 /* Even if the original location is out of scope, the newly
6671 substituted one is not. */
6672 if (TREE_CODE (r) == VAR_DECL)
6674 DECL_DEAD_FOR_LOCAL (r) = 0;
6675 DECL_INITIALIZED_P (r) = 0;
6680 /* A static data member declaration is always marked
6681 external when it is declared in-class, even if an
6682 initializer is present. We mimic the non-template
6684 DECL_EXTERNAL (r) = 1;
6686 register_specialization (r, gen_tmpl, argvec);
6687 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
6688 SET_DECL_IMPLICIT_INSTANTIATION (r);
6691 register_local_specialization (r, t);
6693 TREE_CHAIN (r) = NULL_TREE;
6702 /* Restore the file and line information. */
6703 input_location = saved_loc;
6708 /* Substitute into the ARG_TYPES of a function type. */
6711 tsubst_arg_types (tree arg_types,
6713 tsubst_flags_t complain,
6716 tree remaining_arg_types;
6719 if (!arg_types || arg_types == void_list_node)
6722 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
6723 args, complain, in_decl);
6724 if (remaining_arg_types == error_mark_node)
6725 return error_mark_node;
6727 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
6728 if (type == error_mark_node)
6729 return error_mark_node;
6730 if (VOID_TYPE_P (type))
6732 if (complain & tf_error)
6734 error ("invalid parameter type %qT", type);
6736 cp_error_at ("in declaration %qD", in_decl);
6738 return error_mark_node;
6741 /* Do array-to-pointer, function-to-pointer conversion, and ignore
6742 top-level qualifiers as required. */
6743 type = TYPE_MAIN_VARIANT (type_decays_to (type));
6745 /* Note that we do not substitute into default arguments here. The
6746 standard mandates that they be instantiated only when needed,
6747 which is done in build_over_call. */
6748 return hash_tree_cons (TREE_PURPOSE (arg_types), type,
6749 remaining_arg_types);
6753 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
6754 *not* handle the exception-specification for FNTYPE, because the
6755 initial substitution of explicitly provided template parameters
6756 during argument deduction forbids substitution into the
6757 exception-specification:
6761 All references in the function type of the function template to the
6762 corresponding template parameters are replaced by the specified tem-
6763 plate argument values. If a substitution in a template parameter or
6764 in the function type of the function template results in an invalid
6765 type, type deduction fails. [Note: The equivalent substitution in
6766 exception specifications is done only when the function is instanti-
6767 ated, at which point a program is ill-formed if the substitution
6768 results in an invalid type.] */
6771 tsubst_function_type (tree t,
6773 tsubst_flags_t complain,
6780 /* The TYPE_CONTEXT is not used for function/method types. */
6781 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
6783 /* Substitute the return type. */
6784 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
6785 if (return_type == error_mark_node)
6786 return error_mark_node;
6787 /* The standard does not presently indicate that creation of a
6788 function type with an invalid return type is a deduction failure.
6789 However, that is clearly analogous to creating an array of "void"
6790 or a reference to a reference. This is core issue #486. */
6791 if (TREE_CODE (return_type) == ARRAY_TYPE
6792 || TREE_CODE (return_type) == FUNCTION_TYPE)
6794 if (complain & tf_error)
6796 if (TREE_CODE (return_type) == ARRAY_TYPE)
6797 error ("function returning an array");
6799 error ("function returning a function");
6801 return error_mark_node;
6804 /* Substitute the argument types. */
6805 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
6807 if (arg_types == error_mark_node)
6808 return error_mark_node;
6810 /* Construct a new type node and return it. */
6811 if (TREE_CODE (t) == FUNCTION_TYPE)
6812 fntype = build_function_type (return_type, arg_types);
6815 tree r = TREE_TYPE (TREE_VALUE (arg_types));
6816 if (! IS_AGGR_TYPE (r))
6820 Type deduction may fail for any of the following
6823 -- Attempting to create "pointer to member of T" when T
6824 is not a class type. */
6825 if (complain & tf_error)
6826 error ("creating pointer to member function of non-class type %qT",
6828 return error_mark_node;
6831 fntype = build_method_type_directly (r, return_type,
6832 TREE_CHAIN (arg_types));
6834 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
6835 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
6840 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
6841 ARGS into that specification, and return the substituted
6842 specification. If there is no specification, return NULL_TREE. */
6845 tsubst_exception_specification (tree fntype,
6847 tsubst_flags_t complain,
6853 specs = TYPE_RAISES_EXCEPTIONS (fntype);
6854 new_specs = NULL_TREE;
6857 if (! TREE_VALUE (specs))
6863 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
6864 if (spec == error_mark_node)
6866 new_specs = add_exception_specifier (new_specs, spec, complain);
6867 specs = TREE_CHAIN (specs);
6873 /* Substitute into the PARMS of a call-declarator. */
6876 tsubst_call_declarator_parms (tree parms,
6878 tsubst_flags_t complain,
6885 if (!parms || parms == void_list_node)
6888 new_parms = tsubst_call_declarator_parms (TREE_CHAIN (parms),
6889 args, complain, in_decl);
6891 /* Figure out the type of this parameter. */
6892 type = tsubst (TREE_VALUE (parms), args, complain, in_decl);
6894 /* Figure out the default argument as well. Note that we use
6895 tsubst_expr since the default argument is really an expression. */
6896 defarg = tsubst_expr (TREE_PURPOSE (parms), args, complain, in_decl);
6898 /* Chain this parameter on to the front of those we have already
6899 processed. We don't use hash_tree_cons because that function
6900 doesn't check TREE_PARMLIST. */
6901 new_parms = tree_cons (defarg, type, new_parms);
6906 /* Take the tree structure T and replace template parameters used
6907 therein with the argument vector ARGS. IN_DECL is an associated
6908 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
6909 Issue error and warning messages under control of COMPLAIN. Note
6910 that we must be relatively non-tolerant of extensions here, in
6911 order to preserve conformance; if we allow substitutions that
6912 should not be allowed, we may allow argument deductions that should
6913 not succeed, and therefore report ambiguous overload situations
6914 where there are none. In theory, we could allow the substitution,
6915 but indicate that it should have failed, and allow our caller to
6916 make sure that the right thing happens, but we don't try to do this
6919 This function is used for dealing with types, decls and the like;
6920 for expressions, use tsubst_expr or tsubst_copy. */
6923 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6927 if (t == NULL_TREE || t == error_mark_node
6928 || t == integer_type_node
6929 || t == void_type_node
6930 || t == char_type_node
6931 || t == unknown_type_node
6932 || TREE_CODE (t) == NAMESPACE_DECL)
6936 return tsubst_decl (t, args, complain);
6938 if (TREE_CODE (t) == IDENTIFIER_NODE)
6939 type = IDENTIFIER_TYPE_VALUE (t);
6941 type = TREE_TYPE (t);
6943 gcc_assert (type != unknown_type_node);
6946 && TREE_CODE (t) != TYPENAME_TYPE
6947 && TREE_CODE (t) != IDENTIFIER_NODE
6948 && TREE_CODE (t) != FUNCTION_TYPE
6949 && TREE_CODE (t) != METHOD_TYPE)
6950 type = tsubst (type, args, complain, in_decl);
6951 if (type == error_mark_node)
6952 return error_mark_node;
6954 switch (TREE_CODE (t))
6959 return tsubst_aggr_type (t, args, complain, in_decl,
6960 /*entering_scope=*/0);
6963 case IDENTIFIER_NODE:
6975 if (t == integer_type_node)
6978 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
6979 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
6983 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
6985 /* The array dimension behaves like a non-type template arg,
6986 in that we want to fold it as much as possible. */
6987 max = tsubst_template_arg (omax, args, complain, in_decl);
6988 max = fold_decl_constant_value (max);
6990 if (integer_zerop (omax))
6992 /* Still allow an explicit array of size zero. */
6994 pedwarn ("creating array with size zero");
6996 else if (integer_zerop (max)
6997 || (TREE_CODE (max) == INTEGER_CST
6998 && INT_CST_LT (max, integer_zero_node)))
7002 Type deduction may fail for any of the following
7005 Attempting to create an array with a size that is
7006 zero or negative. */
7007 if (complain & tf_error)
7008 error ("creating array with size zero (%qE)", max);
7010 return error_mark_node;
7013 return compute_array_index_type (NULL_TREE, max);
7016 case TEMPLATE_TYPE_PARM:
7017 case TEMPLATE_TEMPLATE_PARM:
7018 case BOUND_TEMPLATE_TEMPLATE_PARM:
7019 case TEMPLATE_PARM_INDEX:
7024 tree arg = NULL_TREE;
7028 gcc_assert (TREE_VEC_LENGTH (args) > 0);
7029 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7030 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
7031 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7033 idx = TEMPLATE_TYPE_IDX (t);
7034 level = TEMPLATE_TYPE_LEVEL (t);
7038 idx = TEMPLATE_PARM_IDX (t);
7039 level = TEMPLATE_PARM_LEVEL (t);
7042 levels = TMPL_ARGS_DEPTH (args);
7043 if (level <= levels)
7044 arg = TMPL_ARG (args, level, idx);
7046 if (arg == error_mark_node)
7047 return error_mark_node;
7048 else if (arg != NULL_TREE)
7050 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
7052 gcc_assert (TYPE_P (arg));
7053 return cp_build_qualified_type_real
7054 (arg, cp_type_quals (arg) | cp_type_quals (t),
7055 complain | tf_ignore_bad_quals);
7057 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7059 /* We are processing a type constructed from a
7060 template template parameter. */
7061 tree argvec = tsubst (TYPE_TI_ARGS (t),
7062 args, complain, in_decl);
7063 if (argvec == error_mark_node)
7064 return error_mark_node;
7066 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
7067 are resolving nested-types in the signature of a
7068 member function templates. Otherwise ARG is a
7069 TEMPLATE_DECL and is the real template to be
7071 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
7072 arg = TYPE_NAME (arg);
7074 r = lookup_template_class (arg,
7077 /*entering_scope=*/0,
7079 return cp_build_qualified_type_real
7080 (r, TYPE_QUALS (t), complain);
7083 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
7088 /* This can happen during the attempted tsubst'ing in
7089 unify. This means that we don't yet have any information
7090 about the template parameter in question. */
7093 /* If we get here, we must have been looking at a parm for a
7094 more deeply nested template. Make a new version of this
7095 template parameter, but with a lower level. */
7096 switch (TREE_CODE (t))
7098 case TEMPLATE_TYPE_PARM:
7099 case TEMPLATE_TEMPLATE_PARM:
7100 case BOUND_TEMPLATE_TEMPLATE_PARM:
7101 if (cp_type_quals (t))
7103 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
7104 r = cp_build_qualified_type_real
7105 (r, cp_type_quals (t),
7106 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
7107 ? tf_ignore_bad_quals : 0));
7112 TEMPLATE_TYPE_PARM_INDEX (r)
7113 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
7115 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
7116 TYPE_MAIN_VARIANT (r) = r;
7117 TYPE_POINTER_TO (r) = NULL_TREE;
7118 TYPE_REFERENCE_TO (r) = NULL_TREE;
7120 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
7122 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
7124 if (argvec == error_mark_node)
7125 return error_mark_node;
7127 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
7128 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
7133 case TEMPLATE_PARM_INDEX:
7134 r = reduce_template_parm_level (t, type, levels);
7146 tree purpose, value, chain;
7148 if (t == void_list_node)
7151 purpose = TREE_PURPOSE (t);
7154 purpose = tsubst (purpose, args, complain, in_decl);
7155 if (purpose == error_mark_node)
7156 return error_mark_node;
7158 value = TREE_VALUE (t);
7161 value = tsubst (value, args, complain, in_decl);
7162 if (value == error_mark_node)
7163 return error_mark_node;
7165 chain = TREE_CHAIN (t);
7166 if (chain && chain != void_type_node)
7168 chain = tsubst (chain, args, complain, in_decl);
7169 if (chain == error_mark_node)
7170 return error_mark_node;
7172 if (purpose == TREE_PURPOSE (t)
7173 && value == TREE_VALUE (t)
7174 && chain == TREE_CHAIN (t))
7176 return hash_tree_cons (purpose, value, chain);
7180 /* We should never be tsubsting a binfo. */
7184 /* A vector of template arguments. */
7186 return tsubst_template_args (t, args, complain, in_decl);
7189 case REFERENCE_TYPE:
7191 enum tree_code code;
7193 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
7196 code = TREE_CODE (t);
7201 Type deduction may fail for any of the following
7204 -- Attempting to create a pointer to reference type.
7205 -- Attempting to create a reference to a reference type or
7206 a reference to void. */
7207 if (TREE_CODE (type) == REFERENCE_TYPE
7208 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
7210 static location_t last_loc;
7212 /* We keep track of the last time we issued this error
7213 message to avoid spewing a ton of messages during a
7214 single bad template instantiation. */
7215 if (complain & tf_error
7216 #ifdef USE_MAPPED_LOCATION
7217 && last_loc != input_location
7219 && (last_loc.line != input_line
7220 || last_loc.file != input_filename)
7224 if (TREE_CODE (type) == VOID_TYPE)
7225 error ("forming reference to void");
7227 error ("forming %s to reference type %qT",
7228 (code == POINTER_TYPE) ? "pointer" : "reference",
7230 last_loc = input_location;
7233 return error_mark_node;
7235 else if (code == POINTER_TYPE)
7237 r = build_pointer_type (type);
7238 if (TREE_CODE (type) == METHOD_TYPE)
7239 r = build_ptrmemfunc_type (r);
7242 r = build_reference_type (type);
7243 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7245 if (r != error_mark_node)
7246 /* Will this ever be needed for TYPE_..._TO values? */
7253 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
7254 if (r == error_mark_node || !IS_AGGR_TYPE (r))
7258 Type deduction may fail for any of the following
7261 -- Attempting to create "pointer to member of T" when T
7262 is not a class type. */
7263 if (complain & tf_error)
7264 error ("creating pointer to member of non-class type %qT", r);
7265 return error_mark_node;
7267 if (TREE_CODE (type) == REFERENCE_TYPE)
7269 if (complain & tf_error)
7270 error ("creating pointer to member reference type %qT", type);
7272 return error_mark_node;
7274 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
7275 if (TREE_CODE (type) == FUNCTION_TYPE)
7277 /* The type of the implicit object parameter gets its
7278 cv-qualifiers from the FUNCTION_TYPE. */
7280 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
7281 cp_type_quals (type));
7283 method_type = build_method_type_directly (this_type,
7285 TYPE_ARG_TYPES (type));
7286 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
7287 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
7291 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
7300 fntype = tsubst_function_type (t, args, complain, in_decl);
7301 if (fntype == error_mark_node)
7302 return error_mark_node;
7304 /* Substitute the exception specification. */
7305 specs = tsubst_exception_specification (t, args, complain,
7308 fntype = build_exception_variant (fntype, specs);
7313 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
7314 if (domain == error_mark_node)
7315 return error_mark_node;
7317 /* As an optimization, we avoid regenerating the array type if
7318 it will obviously be the same as T. */
7319 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
7322 /* These checks should match the ones in grokdeclarator.
7326 The deduction may fail for any of the following reasons:
7328 -- Attempting to create an array with an element type that
7329 is void, a function type, or a reference type, or [DR337]
7330 an abstract class type. */
7331 if (TREE_CODE (type) == VOID_TYPE
7332 || TREE_CODE (type) == FUNCTION_TYPE
7333 || TREE_CODE (type) == REFERENCE_TYPE)
7335 if (complain & tf_error)
7336 error ("creating array of %qT", type);
7337 return error_mark_node;
7339 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
7341 if (complain & tf_error)
7342 error ("creating array of %qT, which is an abstract class type",
7344 return error_mark_node;
7347 r = build_cplus_array_type (type, domain);
7354 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7355 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7357 if (e1 == error_mark_node || e2 == error_mark_node)
7358 return error_mark_node;
7360 return fold (build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2));
7366 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7367 if (e == error_mark_node)
7368 return error_mark_node;
7370 return fold (build1 (TREE_CODE (t), TREE_TYPE (t), e));
7375 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7376 in_decl, /*entering_scope=*/1);
7377 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
7380 if (ctx == error_mark_node || f == error_mark_node)
7381 return error_mark_node;
7383 if (!IS_AGGR_TYPE (ctx))
7385 if (complain & tf_error)
7386 error ("%qT is not a class, struct, or union type", ctx);
7387 return error_mark_node;
7389 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
7391 /* Normally, make_typename_type does not require that the CTX
7392 have complete type in order to allow things like:
7394 template <class T> struct S { typename S<T>::X Y; };
7396 But, such constructs have already been resolved by this
7397 point, so here CTX really should have complete type, unless
7398 it's a partial instantiation. */
7399 ctx = complete_type (ctx);
7400 if (!COMPLETE_TYPE_P (ctx))
7402 if (complain & tf_error)
7403 cxx_incomplete_type_error (NULL_TREE, ctx);
7404 return error_mark_node;
7408 f = make_typename_type (ctx, f, typename_type,
7409 (complain & tf_error) | tf_keep_type_decl);
7410 if (f == error_mark_node)
7412 if (TREE_CODE (f) == TYPE_DECL)
7414 complain |= tf_ignore_bad_quals;
7418 if (TREE_CODE (f) != TYPENAME_TYPE)
7420 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
7421 error ("%qT resolves to %qT, which is not an enumeration type",
7423 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
7424 error ("%qT resolves to %qT, which is is not a class type",
7428 return cp_build_qualified_type_real
7429 (f, cp_type_quals (f) | cp_type_quals (t), complain);
7432 case UNBOUND_CLASS_TEMPLATE:
7434 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
7435 in_decl, /*entering_scope=*/1);
7436 tree name = TYPE_IDENTIFIER (t);
7437 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
7439 if (ctx == error_mark_node || name == error_mark_node)
7440 return error_mark_node;
7443 parm_list = tsubst_template_parms (parm_list, args, complain);
7444 return make_unbound_class_template (ctx, name, parm_list, complain);
7454 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7455 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl);
7456 if (e1 == error_mark_node || e2 == error_mark_node)
7457 return error_mark_node;
7459 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
7464 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
7465 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
7466 if (e1 == error_mark_node || e2 == error_mark_node)
7467 return error_mark_node;
7469 return build_nt (TREE_CODE (t), e1, e2);
7476 type = finish_typeof (tsubst_expr (TYPEOF_TYPE_EXPR (t), args,
7477 complain, in_decl));
7478 return cp_build_qualified_type_real (type,
7480 | cp_type_quals (type),
7485 sorry ("use of %qs in template",
7486 tree_code_name [(int) TREE_CODE (t)]);
7487 return error_mark_node;
7491 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
7492 type of the expression on the left-hand side of the "." or "->"
7496 tsubst_baselink (tree baselink, tree object_type,
7497 tree args, tsubst_flags_t complain, tree in_decl)
7500 tree qualifying_scope;
7502 tree template_args = 0;
7503 bool template_id_p = false;
7505 /* A baselink indicates a function from a base class. The
7506 BASELINK_ACCESS_BINFO and BASELINK_BINFO are going to have
7507 non-dependent types; otherwise, the lookup could not have
7508 succeeded. However, they may indicate bases of the template
7509 class, rather than the instantiated class.
7511 In addition, lookups that were not ambiguous before may be
7512 ambiguous now. Therefore, we perform the lookup again. */
7513 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
7514 fns = BASELINK_FUNCTIONS (baselink);
7515 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
7517 template_id_p = true;
7518 template_args = TREE_OPERAND (fns, 1);
7519 fns = TREE_OPERAND (fns, 0);
7521 template_args = tsubst_template_args (template_args, args,
7524 name = DECL_NAME (get_first_fn (fns));
7525 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
7527 /* If lookup found a single function, mark it as used at this
7528 point. (If it lookup found multiple functions the one selected
7529 later by overload resolution will be marked as used at that
7531 if (BASELINK_P (baselink))
7532 fns = BASELINK_FUNCTIONS (baselink);
7533 if (!template_id_p && !really_overloaded_fn (fns))
7534 mark_used (OVL_CURRENT (fns));
7536 /* Add back the template arguments, if present. */
7537 if (BASELINK_P (baselink) && template_id_p)
7538 BASELINK_FUNCTIONS (baselink)
7539 = build_nt (TEMPLATE_ID_EXPR,
7540 BASELINK_FUNCTIONS (baselink),
7544 object_type = current_class_type;
7545 return adjust_result_of_qualified_name_lookup (baselink,
7550 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
7551 true if the qualified-id will be a postfix-expression in-and-of
7552 itself; false if more of the postfix-expression follows the
7553 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
7557 tsubst_qualified_id (tree qualified_id, tree args,
7558 tsubst_flags_t complain, tree in_decl,
7559 bool done, bool address_p)
7567 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
7569 /* Figure out what name to look up. */
7570 name = TREE_OPERAND (qualified_id, 1);
7571 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
7574 template_args = TREE_OPERAND (name, 1);
7576 template_args = tsubst_template_args (template_args, args,
7578 name = TREE_OPERAND (name, 0);
7582 is_template = false;
7583 template_args = NULL_TREE;
7586 /* Substitute into the qualifying scope. When there are no ARGS, we
7587 are just trying to simplify a non-dependent expression. In that
7588 case the qualifying scope may be dependent, and, in any case,
7589 substituting will not help. */
7590 scope = TREE_OPERAND (qualified_id, 0);
7593 scope = tsubst (scope, args, complain, in_decl);
7594 expr = tsubst_copy (name, args, complain, in_decl);
7599 if (dependent_type_p (scope))
7600 return build_nt (SCOPE_REF, scope, expr);
7602 if (!BASELINK_P (name) && !DECL_P (expr))
7604 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7605 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
7606 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
7608 if (complain & tf_error)
7610 error ("dependent-name %qE is parsed as a non-type, but "
7611 "instantiation yields a type", qualified_id);
7612 inform ("say %<typename %E%> if a type is meant", qualified_id);
7614 return error_mark_node;
7620 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
7622 /* Remember that there was a reference to this entity. */
7626 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
7628 if (complain & tf_error)
7629 qualified_name_lookup_error (scope,
7630 TREE_OPERAND (qualified_id, 1),
7632 return error_mark_node;
7636 expr = lookup_template_function (expr, template_args);
7638 if (expr == error_mark_node && complain & tf_error)
7639 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
7641 else if (TYPE_P (scope))
7643 expr = (adjust_result_of_qualified_name_lookup
7644 (expr, scope, current_class_type));
7645 expr = finish_qualified_id_expr (scope, expr, done, address_p);
7648 expr = convert_from_reference (expr);
7653 /* Like tsubst, but deals with expressions. This function just replaces
7654 template parms; to finish processing the resultant expression, use
7658 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7660 enum tree_code code;
7663 if (t == NULL_TREE || t == error_mark_node)
7666 code = TREE_CODE (t);
7671 r = retrieve_local_specialization (t);
7672 gcc_assert (r != NULL);
7681 if (DECL_TEMPLATE_PARM_P (t))
7682 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
7683 /* There is no need to substitute into namespace-scope
7685 if (DECL_NAMESPACE_SCOPE_P (t))
7687 /* If ARGS is NULL, then T is known to be non-dependent. */
7688 if (args == NULL_TREE)
7689 return integral_constant_value (t);
7691 /* Unfortunately, we cannot just call lookup_name here.
7694 template <int I> int f() {
7696 struct S { void g() { E e = a; } };
7699 When we instantiate f<7>::S::g(), say, lookup_name is not
7700 clever enough to find f<7>::a. */
7702 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
7703 /*entering_scope=*/0);
7705 for (v = TYPE_VALUES (enum_type);
7708 if (TREE_PURPOSE (v) == DECL_NAME (t))
7709 return TREE_VALUE (v);
7711 /* We didn't find the name. That should never happen; if
7712 name-lookup found it during preliminary parsing, we
7713 should find it again here during instantiation. */
7719 if (DECL_CONTEXT (t))
7723 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
7724 /*entering_scope=*/1);
7725 if (ctx != DECL_CONTEXT (t))
7727 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
7730 if (complain & tf_error)
7731 error ("using invalid field %qD", t);
7732 return error_mark_node;
7742 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
7743 || local_variable_p (t))
7744 t = tsubst (t, args, complain, in_decl);
7749 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
7752 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7753 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
7754 args, complain, in_decl);
7755 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
7756 return tsubst (t, args, complain, in_decl);
7757 else if (DECL_CLASS_SCOPE_P (t)
7758 && uses_template_parms (DECL_CONTEXT (t)))
7760 /* Template template argument like the following example need
7763 template <template <class> class TT> struct C {};
7764 template <class T> struct D {
7765 template <class U> struct E {};
7770 We are processing the template argument `E' in #1 for
7771 the template instantiation #2. Originally, `E' is a
7772 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
7773 have to substitute this with one having context `D<int>'. */
7775 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
7776 return lookup_field (context, DECL_NAME(t), 0, false);
7779 /* Ordinary template template argument. */
7783 case REINTERPRET_CAST_EXPR:
7784 case CONST_CAST_EXPR:
7785 case STATIC_CAST_EXPR:
7786 case DYNAMIC_CAST_EXPR:
7789 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7790 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7794 case TRUTH_NOT_EXPR:
7797 case CONVERT_EXPR: /* Unary + */
7806 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
7807 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
7814 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
7815 name = TREE_OPERAND (t, 1);
7816 if (TREE_CODE (name) == BIT_NOT_EXPR)
7818 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7820 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7822 else if (TREE_CODE (name) == SCOPE_REF
7823 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
7825 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
7827 name = TREE_OPERAND (name, 1);
7828 name = tsubst_copy (TREE_OPERAND (name, 0), args,
7830 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
7831 name = build_nt (SCOPE_REF, base, name);
7833 else if (TREE_CODE (name) == BASELINK)
7834 name = tsubst_baselink (name,
7835 non_reference (TREE_TYPE (object)),
7839 name = tsubst_copy (name, args, complain, in_decl);
7840 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
7846 case TRUNC_DIV_EXPR:
7848 case FLOOR_DIV_EXPR:
7849 case ROUND_DIV_EXPR:
7850 case EXACT_DIV_EXPR:
7854 case TRUNC_MOD_EXPR:
7855 case FLOOR_MOD_EXPR:
7856 case TRUTH_ANDIF_EXPR:
7857 case TRUTH_ORIF_EXPR:
7858 case TRUTH_AND_EXPR:
7876 case PREDECREMENT_EXPR:
7877 case PREINCREMENT_EXPR:
7878 case POSTDECREMENT_EXPR:
7879 case POSTINCREMENT_EXPR:
7881 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7882 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7887 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7888 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7889 NULL_TREE, NULL_TREE);
7892 return build_nt (code,
7893 tsubst_copy (TREE_OPERAND (t, 0), args,
7895 tsubst_copy (TREE_OPERAND (t, 1), args, complain,
7901 case PSEUDO_DTOR_EXPR:
7904 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7905 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7906 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7907 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
7914 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7915 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
7916 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
7917 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
7924 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
7925 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
7926 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
7927 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
7931 case TEMPLATE_ID_EXPR:
7933 /* Substituted template arguments */
7934 tree fn = TREE_OPERAND (t, 0);
7935 tree targs = TREE_OPERAND (t, 1);
7937 fn = tsubst_copy (fn, args, complain, in_decl);
7939 targs = tsubst_template_args (targs, args, complain, in_decl);
7941 return lookup_template_function (fn, targs);
7946 tree purpose, value, chain;
7948 if (t == void_list_node)
7951 purpose = TREE_PURPOSE (t);
7953 purpose = tsubst_copy (purpose, args, complain, in_decl);
7954 value = TREE_VALUE (t);
7956 value = tsubst_copy (value, args, complain, in_decl);
7957 chain = TREE_CHAIN (t);
7958 if (chain && chain != void_type_node)
7959 chain = tsubst_copy (chain, args, complain, in_decl);
7960 if (purpose == TREE_PURPOSE (t)
7961 && value == TREE_VALUE (t)
7962 && chain == TREE_CHAIN (t))
7964 return tree_cons (purpose, value, chain);
7971 case TEMPLATE_TYPE_PARM:
7972 case TEMPLATE_TEMPLATE_PARM:
7973 case BOUND_TEMPLATE_TEMPLATE_PARM:
7974 case TEMPLATE_PARM_INDEX:
7976 case REFERENCE_TYPE:
7982 case UNBOUND_CLASS_TEMPLATE:
7985 return tsubst (t, args, complain, in_decl);
7987 case IDENTIFIER_NODE:
7988 if (IDENTIFIER_TYPENAME_P (t))
7990 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7991 return mangle_conv_op_name_for_type (new_type);
7998 r = build_constructor
7999 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8000 tsubst_copy (CONSTRUCTOR_ELTS (t), args, complain, in_decl));
8001 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
8006 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
8008 tsubst (TREE_TYPE (t), args, complain, in_decl));
8010 case CLEANUP_POINT_EXPR:
8011 /* We shouldn't have built any of these during initial template
8012 generation. Instead, they should be built during instantiation
8013 in response to the saved STMT_IS_FULL_EXPR_P setting. */
8021 /* Like tsubst_copy for expressions, etc. but also does semantic
8025 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8029 if (t == NULL_TREE || t == error_mark_node)
8032 if (EXPR_HAS_LOCATION (t))
8033 input_location = EXPR_LOCATION (t);
8034 if (STATEMENT_CODE_P (TREE_CODE (t)))
8035 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
8037 switch (TREE_CODE (t))
8039 case STATEMENT_LIST:
8041 tree_stmt_iterator i;
8042 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
8043 tsubst_expr (tsi_stmt (i), args, complain, in_decl);
8047 case CTOR_INITIALIZER:
8048 finish_mem_initializers (tsubst_initializer_list
8049 (TREE_OPERAND (t, 0), args));
8053 finish_return_stmt (tsubst_expr (TREE_OPERAND (t, 0),
8054 args, complain, in_decl));
8058 tmp = tsubst_expr (EXPR_STMT_EXPR (t), args, complain, in_decl);
8059 if (EXPR_STMT_STMT_EXPR_RESULT (t))
8060 finish_stmt_expr_expr (tmp, cur_stmt_expr);
8062 finish_expr_stmt (tmp);
8066 do_using_directive (tsubst_expr (USING_STMT_NAMESPACE (t),
8067 args, complain, in_decl));
8075 decl = DECL_EXPR_DECL (t);
8076 if (TREE_CODE (decl) == LABEL_DECL)
8077 finish_label_decl (DECL_NAME (decl));
8078 else if (TREE_CODE (decl) == USING_DECL)
8080 tree scope = DECL_INITIAL (decl);
8081 tree name = DECL_NAME (decl);
8084 scope = tsubst_expr (scope, args, complain, in_decl);
8085 decl = lookup_qualified_name (scope, name,
8086 /*is_type_p=*/false,
8087 /*complain=*/false);
8088 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
8089 qualified_name_lookup_error (scope, name, decl);
8091 do_local_using_decl (decl, scope, name);
8095 init = DECL_INITIAL (decl);
8096 decl = tsubst (decl, args, complain, in_decl);
8097 if (decl != error_mark_node)
8100 DECL_INITIAL (decl) = error_mark_node;
8101 /* By marking the declaration as instantiated, we avoid
8102 trying to instantiate it. Since instantiate_decl can't
8103 handle local variables, and since we've already done
8104 all that needs to be done, that's the right thing to
8106 if (TREE_CODE (decl) == VAR_DECL)
8107 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8108 if (TREE_CODE (decl) == VAR_DECL
8109 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
8110 /* Anonymous aggregates are a special case. */
8111 finish_anon_union (decl);
8114 maybe_push_decl (decl);
8115 if (TREE_CODE (decl) == VAR_DECL
8116 && DECL_PRETTY_FUNCTION_P (decl))
8118 /* For __PRETTY_FUNCTION__ we have to adjust the
8120 const char *const name
8121 = cxx_printable_name (current_function_decl, 2);
8122 init = cp_fname_init (name, &TREE_TYPE (decl));
8125 init = tsubst_expr (init, args, complain, in_decl);
8126 cp_finish_decl (decl, init, NULL_TREE, 0);
8131 /* A DECL_EXPR can also be used as an expression, in the condition
8132 clause of an if/for/while construct. */
8137 stmt = begin_for_stmt ();
8138 tsubst_expr (FOR_INIT_STMT (t), args, complain, in_decl);
8139 finish_for_init_stmt (stmt);
8140 tmp = tsubst_expr (FOR_COND (t), args, complain, in_decl);
8141 finish_for_cond (tmp, stmt);
8142 tmp = tsubst_expr (FOR_EXPR (t), args, complain, in_decl);
8143 finish_for_expr (tmp, stmt);
8144 tsubst_expr (FOR_BODY (t), args, complain, in_decl);
8145 finish_for_stmt (stmt);
8149 stmt = begin_while_stmt ();
8150 tmp = tsubst_expr (WHILE_COND (t), args, complain, in_decl);
8151 finish_while_stmt_cond (tmp, stmt);
8152 tsubst_expr (WHILE_BODY (t), args, complain, in_decl);
8153 finish_while_stmt (stmt);
8157 stmt = begin_do_stmt ();
8158 tsubst_expr (DO_BODY (t), args, complain, in_decl);
8159 finish_do_body (stmt);
8160 tmp = tsubst_expr (DO_COND (t), args, complain, in_decl);
8161 finish_do_stmt (tmp, stmt);
8165 stmt = begin_if_stmt ();
8166 tmp = tsubst_expr (IF_COND (t), args, complain, in_decl);
8167 finish_if_stmt_cond (tmp, stmt);
8168 tsubst_expr (THEN_CLAUSE (t), args, complain, in_decl);
8169 finish_then_clause (stmt);
8171 if (ELSE_CLAUSE (t))
8173 begin_else_clause (stmt);
8174 tsubst_expr (ELSE_CLAUSE (t), args, complain, in_decl);
8175 finish_else_clause (stmt);
8178 finish_if_stmt (stmt);
8182 if (BIND_EXPR_BODY_BLOCK (t))
8183 stmt = begin_function_body ();
8185 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
8186 ? BCS_TRY_BLOCK : 0);
8188 tsubst_expr (BIND_EXPR_BODY (t), args, complain, in_decl);
8190 if (BIND_EXPR_BODY_BLOCK (t))
8191 finish_function_body (stmt);
8193 finish_compound_stmt (stmt);
8197 finish_break_stmt ();
8201 finish_continue_stmt ();
8205 stmt = begin_switch_stmt ();
8206 tmp = tsubst_expr (SWITCH_STMT_COND (t), args, complain, in_decl);
8207 finish_switch_cond (tmp, stmt);
8208 tsubst_expr (SWITCH_STMT_BODY (t), args, complain, in_decl);
8209 finish_switch_stmt (stmt);
8212 case CASE_LABEL_EXPR:
8213 finish_case_label (tsubst_expr (CASE_LOW (t), args, complain, in_decl),
8214 tsubst_expr (CASE_HIGH (t), args, complain,
8219 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
8223 tmp = GOTO_DESTINATION (t);
8224 if (TREE_CODE (tmp) != LABEL_DECL)
8225 /* Computed goto's must be tsubst'd into. On the other hand,
8226 non-computed gotos must not be; the identifier in question
8227 will have no binding. */
8228 tmp = tsubst_expr (tmp, args, complain, in_decl);
8230 tmp = DECL_NAME (tmp);
8231 finish_goto_stmt (tmp);
8235 tmp = finish_asm_stmt
8236 (ASM_VOLATILE_P (t),
8237 tsubst_expr (ASM_STRING (t), args, complain, in_decl),
8238 tsubst_expr (ASM_OUTPUTS (t), args, complain, in_decl),
8239 tsubst_expr (ASM_INPUTS (t), args, complain, in_decl),
8240 tsubst_expr (ASM_CLOBBERS (t), args, complain, in_decl));
8242 tree asm_expr = tmp;
8243 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
8244 asm_expr = TREE_OPERAND (asm_expr, 0);
8245 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
8252 stmt = begin_try_block ();
8253 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
8254 finish_cleanup_try_block (stmt);
8255 finish_cleanup (tsubst_expr (TRY_HANDLERS (t), args,
8261 if (FN_TRY_BLOCK_P (t))
8262 stmt = begin_function_try_block ();
8264 stmt = begin_try_block ();
8266 tsubst_expr (TRY_STMTS (t), args, complain, in_decl);
8268 if (FN_TRY_BLOCK_P (t))
8269 finish_function_try_block (stmt);
8271 finish_try_block (stmt);
8273 tsubst_expr (TRY_HANDLERS (t), args, complain, in_decl);
8274 if (FN_TRY_BLOCK_P (t))
8275 finish_function_handler_sequence (stmt);
8277 finish_handler_sequence (stmt);
8285 stmt = begin_handler ();
8286 if (HANDLER_PARMS (t))
8288 decl = HANDLER_PARMS (t);
8289 decl = tsubst (decl, args, complain, in_decl);
8290 /* Prevent instantiate_decl from trying to instantiate
8291 this variable. We've already done all that needs to be
8293 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
8297 finish_handler_parms (decl, stmt);
8298 tsubst_expr (HANDLER_BODY (t), args, complain, in_decl);
8299 finish_handler (stmt);
8304 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
8308 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
8310 return tsubst_copy_and_build (t, args, complain, in_decl,
8311 /*function_p=*/false);
8317 /* T is a postfix-expression that is not being used in a function
8318 call. Return the substituted version of T. */
8321 tsubst_non_call_postfix_expression (tree t, tree args,
8322 tsubst_flags_t complain,
8325 if (TREE_CODE (t) == SCOPE_REF)
8326 t = tsubst_qualified_id (t, args, complain, in_decl,
8327 /*done=*/false, /*address_p=*/false);
8329 t = tsubst_copy_and_build (t, args, complain, in_decl,
8330 /*function_p=*/false);
8335 /* Like tsubst but deals with expressions and performs semantic
8336 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
8339 tsubst_copy_and_build (tree t,
8341 tsubst_flags_t complain,
8345 #define RECUR(NODE) \
8346 tsubst_copy_and_build (NODE, args, complain, in_decl, /*function_p=*/false)
8350 if (t == NULL_TREE || t == error_mark_node)
8353 switch (TREE_CODE (t))
8358 case IDENTIFIER_NODE:
8362 tree qualifying_class;
8363 bool non_integral_constant_expression_p;
8364 const char *error_msg;
8366 if (IDENTIFIER_TYPENAME_P (t))
8368 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8369 t = mangle_conv_op_name_for_type (new_type);
8372 /* Look up the name. */
8373 decl = lookup_name (t, 0);
8375 /* By convention, expressions use ERROR_MARK_NODE to indicate
8376 failure, not NULL_TREE. */
8377 if (decl == NULL_TREE)
8378 decl = error_mark_node;
8380 decl = finish_id_expression (t, decl, NULL_TREE,
8383 /*integral_constant_expression_p=*/false,
8384 /*allow_non_integral_constant_expression_p=*/false,
8385 &non_integral_constant_expression_p,
8389 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
8390 decl = unqualified_name_lookup_error (decl);
8394 case TEMPLATE_ID_EXPR:
8397 tree template = RECUR (TREE_OPERAND (t, 0));
8398 tree targs = TREE_OPERAND (t, 1);
8401 targs = tsubst_template_args (targs, args, complain, in_decl);
8403 if (TREE_CODE (template) == COMPONENT_REF)
8405 object = TREE_OPERAND (template, 0);
8406 template = TREE_OPERAND (template, 1);
8410 template = lookup_template_function (template, targs);
8413 return build3 (COMPONENT_REF, TREE_TYPE (template),
8414 object, template, NULL_TREE);
8421 tree r = RECUR (TREE_OPERAND (t, 0));
8423 if (REFERENCE_REF_P (t))
8425 /* A type conversion to reference type will be enclosed in
8426 such an indirect ref, but the substitution of the cast
8427 will have also added such an indirect ref. */
8428 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
8429 r = convert_from_reference (r);
8432 r = build_x_indirect_ref (r, "unary *");
8438 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8439 RECUR (TREE_OPERAND (t, 0)));
8442 return build_functional_cast
8443 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8444 RECUR (TREE_OPERAND (t, 0)));
8446 case REINTERPRET_CAST_EXPR:
8447 return build_reinterpret_cast
8448 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8449 RECUR (TREE_OPERAND (t, 0)));
8451 case CONST_CAST_EXPR:
8452 return build_const_cast
8453 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8454 RECUR (TREE_OPERAND (t, 0)));
8456 case DYNAMIC_CAST_EXPR:
8457 return build_dynamic_cast
8458 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8459 RECUR (TREE_OPERAND (t, 0)));
8461 case STATIC_CAST_EXPR:
8462 return build_static_cast
8463 (tsubst (TREE_TYPE (t), args, complain, in_decl),
8464 RECUR (TREE_OPERAND (t, 0)));
8466 case POSTDECREMENT_EXPR:
8467 case POSTINCREMENT_EXPR:
8468 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8469 args, complain, in_decl);
8470 return build_x_unary_op (TREE_CODE (t), op1);
8472 case PREDECREMENT_EXPR:
8473 case PREINCREMENT_EXPR:
8477 case TRUTH_NOT_EXPR:
8478 case CONVERT_EXPR: /* Unary + */
8481 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
8484 op1 = TREE_OPERAND (t, 0);
8485 if (TREE_CODE (op1) == SCOPE_REF)
8486 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
8487 /*done=*/true, /*address_p=*/true);
8489 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
8491 if (TREE_CODE (op1) == LABEL_DECL)
8492 return finish_label_address_expr (DECL_NAME (op1));
8493 return build_x_unary_op (ADDR_EXPR, op1);
8498 case TRUNC_DIV_EXPR:
8500 case FLOOR_DIV_EXPR:
8501 case ROUND_DIV_EXPR:
8502 case EXACT_DIV_EXPR:
8506 case TRUNC_MOD_EXPR:
8507 case FLOOR_MOD_EXPR:
8508 case TRUTH_ANDIF_EXPR:
8509 case TRUTH_ORIF_EXPR:
8510 case TRUTH_AND_EXPR:
8526 return build_x_binary_op
8528 RECUR (TREE_OPERAND (t, 0)),
8529 RECUR (TREE_OPERAND (t, 1)),
8530 /*overloaded_p=*/NULL);
8533 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
8534 /*address_p=*/false);
8536 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8537 args, complain, in_decl);
8538 return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)),
8539 /*overloaded_p=*/NULL);
8543 op1 = TREE_OPERAND (t, 0);
8546 /* When there are no ARGS, we are trying to evaluate a
8547 non-dependent expression from the parser. Trying to do
8548 the substitutions may not work. */
8550 op1 = TREE_TYPE (op1);
8559 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
8561 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
8565 tree r = build_x_modify_expr
8566 (RECUR (TREE_OPERAND (t, 0)),
8567 TREE_CODE (TREE_OPERAND (t, 1)),
8568 RECUR (TREE_OPERAND (t, 2)));
8569 /* TREE_NO_WARNING must be set if either the expression was
8570 parenthesized or it uses an operator such as >>= rather
8571 than plain assignment. In the former case, it was already
8572 set and must be copied. In the latter case,
8573 build_x_modify_expr sets it and it must not be reset
8575 if (TREE_NO_WARNING (t))
8576 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
8581 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8582 args, complain, in_decl);
8583 /* Remember that there was a reference to this entity. */
8586 return build_x_arrow (op1);
8590 (RECUR (TREE_OPERAND (t, 0)),
8591 RECUR (TREE_OPERAND (t, 1)),
8592 RECUR (TREE_OPERAND (t, 2)),
8593 RECUR (TREE_OPERAND (t, 3)),
8594 NEW_EXPR_USE_GLOBAL (t));
8597 return delete_sanity
8598 (RECUR (TREE_OPERAND (t, 0)),
8599 RECUR (TREE_OPERAND (t, 1)),
8600 DELETE_EXPR_USE_VEC (t),
8601 DELETE_EXPR_USE_GLOBAL (t));
8604 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
8605 RECUR (TREE_OPERAND (t, 1)));
8614 function = TREE_OPERAND (t, 0);
8615 /* When we parsed the expression, we determined whether or
8616 not Koenig lookup should be performed. */
8617 koenig_p = KOENIG_LOOKUP_P (t);
8618 if (TREE_CODE (function) == SCOPE_REF)
8621 function = tsubst_qualified_id (function, args, complain, in_decl,
8623 /*address_p=*/false);
8627 qualified_p = (TREE_CODE (function) == COMPONENT_REF
8628 && (TREE_CODE (TREE_OPERAND (function, 1))
8630 function = tsubst_copy_and_build (function, args, complain,
8633 if (BASELINK_P (function))
8637 call_args = RECUR (TREE_OPERAND (t, 1));
8639 /* We do not perform argument-dependent lookup if normal
8640 lookup finds a non-function, in accordance with the
8641 expected resolution of DR 218. */
8643 && ((is_overloaded_fn (function)
8644 /* If lookup found a member function, the Koenig lookup is
8645 not appropriate, even if an unqualified-name was used
8646 to denote the function. */
8647 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
8648 || TREE_CODE (function) == IDENTIFIER_NODE))
8649 function = perform_koenig_lookup (function, call_args);
8651 if (TREE_CODE (function) == IDENTIFIER_NODE)
8653 unqualified_name_lookup_error (function);
8654 return error_mark_node;
8657 /* Remember that there was a reference to this entity. */
8658 if (DECL_P (function))
8659 mark_used (function);
8661 if (TREE_CODE (function) == OFFSET_REF)
8662 return build_offset_ref_call_from_tree (function, call_args);
8663 if (TREE_CODE (function) == COMPONENT_REF)
8665 if (!BASELINK_P (TREE_OPERAND (function, 1)))
8666 return finish_call_expr (function, call_args,
8667 /*disallow_virtual=*/false,
8668 /*koenig_p=*/false);
8670 return (build_new_method_call
8671 (TREE_OPERAND (function, 0),
8672 TREE_OPERAND (function, 1),
8673 call_args, NULL_TREE,
8674 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL));
8676 return finish_call_expr (function, call_args,
8677 /*disallow_virtual=*/qualified_p,
8682 return build_x_conditional_expr
8683 (RECUR (TREE_OPERAND (t, 0)),
8684 RECUR (TREE_OPERAND (t, 1)),
8685 RECUR (TREE_OPERAND (t, 2)));
8687 case PSEUDO_DTOR_EXPR:
8688 return finish_pseudo_destructor_expr
8689 (RECUR (TREE_OPERAND (t, 0)),
8690 RECUR (TREE_OPERAND (t, 1)),
8691 RECUR (TREE_OPERAND (t, 2)));
8695 tree purpose, value, chain;
8697 if (t == void_list_node)
8700 purpose = TREE_PURPOSE (t);
8702 purpose = RECUR (purpose);
8703 value = TREE_VALUE (t);
8705 value = RECUR (value);
8706 chain = TREE_CHAIN (t);
8707 if (chain && chain != void_type_node)
8708 chain = RECUR (chain);
8709 if (purpose == TREE_PURPOSE (t)
8710 && value == TREE_VALUE (t)
8711 && chain == TREE_CHAIN (t))
8713 return tree_cons (purpose, value, chain);
8721 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
8722 args, complain, in_decl);
8723 /* Remember that there was a reference to this entity. */
8724 if (DECL_P (object))
8727 member = TREE_OPERAND (t, 1);
8728 if (BASELINK_P (member))
8729 member = tsubst_baselink (member,
8730 non_reference (TREE_TYPE (object)),
8731 args, complain, in_decl);
8733 member = tsubst_copy (member, args, complain, in_decl);
8735 if (member == error_mark_node)
8736 return error_mark_node;
8737 else if (!CLASS_TYPE_P (TREE_TYPE (object)))
8739 if (TREE_CODE (member) == BIT_NOT_EXPR)
8740 return finish_pseudo_destructor_expr (object,
8742 TREE_TYPE (object));
8743 else if (TREE_CODE (member) == SCOPE_REF
8744 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
8745 return finish_pseudo_destructor_expr (object,
8747 TREE_TYPE (object));
8749 else if (TREE_CODE (member) == SCOPE_REF
8750 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
8755 /* Lookup the template functions now that we know what the
8757 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
8758 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
8759 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
8760 /*is_type_p=*/false,
8761 /*complain=*/false);
8762 if (BASELINK_P (member))
8764 BASELINK_FUNCTIONS (member)
8765 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
8767 member = (adjust_result_of_qualified_name_lookup
8768 (member, BINFO_TYPE (BASELINK_BINFO (member)),
8769 TREE_TYPE (object)));
8773 qualified_name_lookup_error (TREE_TYPE (object), tmpl,
8775 return error_mark_node;
8778 else if (TREE_CODE (member) == SCOPE_REF
8779 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
8780 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
8782 if (complain & tf_error)
8784 if (TYPE_P (TREE_OPERAND (member, 0)))
8785 error ("%qT is not a class or namespace",
8786 TREE_OPERAND (member, 0));
8788 error ("%qD is not a class or namespace",
8789 TREE_OPERAND (member, 0));
8791 return error_mark_node;
8793 else if (TREE_CODE (member) == FIELD_DECL)
8794 return finish_non_static_data_member (member, object, NULL_TREE);
8796 return finish_class_member_access_expr (object, member);
8801 (RECUR (TREE_OPERAND (t, 0)));
8807 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8810 /* digest_init will do the wrong thing if we let it. */
8811 if (type && TYPE_PTRMEMFUNC_P (type))
8815 /* We do not want to process the purpose of aggregate
8816 initializers as they are identifier nodes which will be
8817 looked up by digest_init. */
8818 purpose_p = !(type && IS_AGGR_TYPE (type));
8819 for (elts = CONSTRUCTOR_ELTS (t);
8821 elts = TREE_CHAIN (elts))
8823 tree purpose = TREE_PURPOSE (elts);
8824 tree value = TREE_VALUE (elts);
8826 if (purpose && purpose_p)
8827 purpose = RECUR (purpose);
8828 value = RECUR (value);
8829 r = tree_cons (purpose, value, r);
8832 r = build_constructor (NULL_TREE, nreverse (r));
8833 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
8836 return digest_init (type, r, 0);
8842 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
8843 if (TYPE_P (operand_0))
8844 return get_typeid (operand_0);
8845 return build_typeid (operand_0);
8855 tree r = tsubst_copy (t, args, complain, in_decl);
8857 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
8858 /* If the original type was a reference, we'll be wrapped in
8859 the appropriate INDIRECT_REF. */
8860 r = convert_from_reference (r);
8865 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
8866 tsubst_copy (TREE_TYPE (t), args, complain,
8870 return fold_offsetof (RECUR (TREE_OPERAND (t, 0)));
8874 tree old_stmt_expr = cur_stmt_expr;
8875 tree stmt_expr = begin_stmt_expr ();
8877 cur_stmt_expr = stmt_expr;
8878 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl);
8879 stmt_expr = finish_stmt_expr (stmt_expr, false);
8880 cur_stmt_expr = old_stmt_expr;
8886 t = tsubst_copy (t, args, complain, in_decl);
8887 /* As in finish_id_expression, we resolve enumeration constants
8888 to their underlying values. */
8889 if (TREE_CODE (t) == CONST_DECL)
8890 return DECL_INITIAL (t);
8894 return tsubst_copy (t, args, complain, in_decl);
8900 /* Verify that the instantiated ARGS are valid. For type arguments,
8901 make sure that the type's linkage is ok. For non-type arguments,
8902 make sure they are constants if they are integral or enumerations.
8903 Emit an error under control of COMPLAIN, and return TRUE on error. */
8906 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
8908 int ix, len = DECL_NTPARMS (tmpl);
8909 bool result = false;
8910 bool error_p = complain & tf_error;
8912 for (ix = 0; ix != len; ix++)
8914 tree t = TREE_VEC_ELT (args, ix);
8918 /* [basic.link]: A name with no linkage (notably, the name
8919 of a class or enumeration declared in a local scope)
8920 shall not be used to declare an entity with linkage.
8921 This implies that names with no linkage cannot be used as
8922 template arguments. */
8923 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
8927 if (TYPE_ANONYMOUS_P (nt))
8928 error ("%qT is/uses anonymous type", t);
8930 error ("%qT uses local type %qT", t, nt);
8934 /* In order to avoid all sorts of complications, we do not
8935 allow variably-modified types as template arguments. */
8936 else if (variably_modified_type_p (t, NULL_TREE))
8938 if (complain & tf_error)
8939 error ("%qT is a variably modified type", t);
8943 /* A non-type argument of integral or enumerated type must be a
8945 else if (TREE_TYPE (t)
8946 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
8947 && !TREE_CONSTANT (t))
8949 if (complain & tf_error)
8950 error ("integral expression %qE is not constant", t);
8954 if (result && error_p)
8955 error (" trying to instantiate %qD", tmpl);
8959 /* Instantiate the indicated variable or function template TMPL with
8960 the template arguments in TARG_PTR. */
8963 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
8969 if (tmpl == error_mark_node)
8970 return error_mark_node;
8972 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
8974 /* If this function is a clone, handle it specially. */
8975 if (DECL_CLONED_FUNCTION_P (tmpl))
8980 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
8982 if (spec == error_mark_node)
8983 return error_mark_node;
8985 /* Look for the clone. */
8986 FOR_EACH_CLONE (clone, spec)
8987 if (DECL_NAME (clone) == DECL_NAME (tmpl))
8989 /* We should always have found the clone by now. */
8994 /* Check to see if we already have this specialization. */
8995 spec = retrieve_specialization (tmpl, targ_ptr,
8996 /*class_specializations_p=*/false);
8997 if (spec != NULL_TREE)
9000 gen_tmpl = most_general_template (tmpl);
9001 if (tmpl != gen_tmpl)
9003 /* The TMPL is a partial instantiation. To get a full set of
9004 arguments we must add the arguments used to perform the
9005 partial instantiation. */
9006 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
9009 /* Check to see if we already have this specialization. */
9010 spec = retrieve_specialization (gen_tmpl, targ_ptr,
9011 /*class_specializations_p=*/false);
9012 if (spec != NULL_TREE)
9016 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
9018 return error_mark_node;
9020 /* We are building a FUNCTION_DECL, during which the access of its
9021 parameters and return types have to be checked. However this
9022 FUNCTION_DECL which is the desired context for access checking
9023 is not built yet. We solve this chicken-and-egg problem by
9024 deferring all checks until we have the FUNCTION_DECL. */
9025 push_deferring_access_checks (dk_deferred);
9027 /* Substitute template parameters. */
9028 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
9029 targ_ptr, complain, gen_tmpl);
9031 /* Now we know the specialization, compute access previously
9033 push_access_scope (fndecl);
9034 perform_deferred_access_checks ();
9035 pop_access_scope (fndecl);
9036 pop_deferring_access_checks ();
9038 /* The DECL_TI_TEMPLATE should always be the immediate parent
9039 template, not the most general template. */
9040 DECL_TI_TEMPLATE (fndecl) = tmpl;
9042 /* If we've just instantiated the main entry point for a function,
9043 instantiate all the alternate entry points as well. We do this
9044 by cloning the instantiation of the main entry point, not by
9045 instantiating the template clones. */
9046 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
9047 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
9052 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
9053 arguments that are being used when calling it. TARGS is a vector
9054 into which the deduced template arguments are placed.
9056 Return zero for success, 2 for an incomplete match that doesn't resolve
9057 all the types, and 1 for complete failure. An error message will be
9058 printed only for an incomplete match.
9060 If FN is a conversion operator, or we are trying to produce a specific
9061 specialization, RETURN_TYPE is the return type desired.
9063 The EXPLICIT_TARGS are explicit template arguments provided via a
9066 The parameter STRICT is one of:
9069 We are deducing arguments for a function call, as in
9073 We are deducing arguments for a conversion function, as in
9077 We are deducing arguments when doing an explicit instantiation
9078 as in [temp.explicit], when determining an explicit specialization
9079 as in [temp.expl.spec], or when taking the address of a function
9080 template, as in [temp.deduct.funcaddr].
9083 We are deducing arguments when calculating the partial
9084 ordering between specializations of function or class
9085 templates, as in [temp.func.order] and [temp.class.order].
9087 LEN is the number of parms to consider before returning success, or -1
9088 for all. This is used in partial ordering to avoid comparing parms for
9089 which no actual argument was passed, since they are not considered in
9090 overload resolution (and are explicitly excluded from consideration in
9091 partial ordering in [temp.func.order]/6). */
9094 fn_type_unification (tree fn,
9095 tree explicit_targs,
9099 unification_kind_t strict,
9106 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
9108 fntype = TREE_TYPE (fn);
9113 The specified template arguments must match the template
9114 parameters in kind (i.e., type, nontype, template), and there
9115 must not be more arguments than there are parameters;
9116 otherwise type deduction fails.
9118 Nontype arguments must match the types of the corresponding
9119 nontype template parameters, or must be convertible to the
9120 types of the corresponding nontype parameters as specified in
9121 _temp.arg.nontype_, otherwise type deduction fails.
9123 All references in the function type of the function template
9124 to the corresponding template parameters are replaced by the
9125 specified template argument values. If a substitution in a
9126 template parameter or in the function type of the function
9127 template results in an invalid type, type deduction fails. */
9129 tree converted_args;
9132 if (explicit_targs == error_mark_node)
9136 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9137 explicit_targs, NULL_TREE, tf_none,
9138 /*require_all_arguments=*/0));
9139 if (converted_args == error_mark_node)
9142 /* Substitute the explicit args into the function type. This is
9143 necessary so that, for instance, explicitly declared function
9144 arguments can match null pointed constants. If we were given
9145 an incomplete set of explicit args, we must not do semantic
9146 processing during substitution as we could create partial
9148 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
9149 processing_template_decl += incomplete;
9150 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
9151 processing_template_decl -= incomplete;
9153 if (fntype == error_mark_node)
9156 /* Place the explicitly specified arguments in TARGS. */
9157 for (i = NUM_TMPL_ARGS (converted_args); i--;)
9158 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
9161 parms = TYPE_ARG_TYPES (fntype);
9162 /* Never do unification on the 'this' parameter. */
9163 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
9164 parms = TREE_CHAIN (parms);
9168 /* We've been given a return type to match, prepend it. */
9169 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
9170 args = tree_cons (NULL_TREE, return_type, args);
9175 /* We allow incomplete unification without an error message here
9176 because the standard doesn't seem to explicitly prohibit it. Our
9177 callers must be ready to deal with unification failures in any
9179 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
9180 targs, parms, args, /*subr=*/0,
9181 strict, /*allow_incomplete*/1, len);
9184 /* All is well so far. Now, check:
9188 When all template arguments have been deduced, all uses of
9189 template parameters in nondeduced contexts are replaced with
9190 the corresponding deduced argument values. If the
9191 substitution results in an invalid type, as described above,
9192 type deduction fails. */
9193 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
9200 /* Adjust types before performing type deduction, as described in
9201 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
9202 sections are symmetric. PARM is the type of a function parameter
9203 or the return type of the conversion function. ARG is the type of
9204 the argument passed to the call, or the type of the value
9205 initialized with the result of the conversion function. */
9208 maybe_adjust_types_for_deduction (unification_kind_t strict,
9221 /* Swap PARM and ARG throughout the remainder of this
9222 function; the handling is precisely symmetric since PARM
9223 will initialize ARG rather than vice versa. */
9231 /* There is nothing to do in this case. */
9235 /* DR 214. [temp.func.order] is underspecified, and leads to no
9236 ordering between things like `T *' and `T const &' for `U *'.
9237 The former has T=U and the latter T=U*. The former looks more
9238 specialized and John Spicer considers it well-formed (the EDG
9239 compiler accepts it).
9241 John also confirms that deduction should proceed as in a function
9242 call. Which implies the usual ARG and PARM conversions as DEDUCE_CALL.
9243 However, in ordering, ARG can have REFERENCE_TYPE, but no argument
9244 to an actual call can have such a type.
9246 If both ARG and PARM are REFERENCE_TYPE, we change neither.
9247 If only ARG is a REFERENCE_TYPE, we look through that and then
9248 proceed as with DEDUCE_CALL (which could further convert it). */
9249 if (TREE_CODE (*arg) == REFERENCE_TYPE)
9251 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9253 *arg = TREE_TYPE (*arg);
9260 if (TREE_CODE (*parm) != REFERENCE_TYPE)
9262 /* [temp.deduct.call]
9264 If P is not a reference type:
9266 --If A is an array type, the pointer type produced by the
9267 array-to-pointer standard conversion (_conv.array_) is
9268 used in place of A for type deduction; otherwise,
9270 --If A is a function type, the pointer type produced by
9271 the function-to-pointer standard conversion
9272 (_conv.func_) is used in place of A for type deduction;
9275 --If A is a cv-qualified type, the top level
9276 cv-qualifiers of A's type are ignored for type
9278 if (TREE_CODE (*arg) == ARRAY_TYPE)
9279 *arg = build_pointer_type (TREE_TYPE (*arg));
9280 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
9281 *arg = build_pointer_type (*arg);
9283 *arg = TYPE_MAIN_VARIANT (*arg);
9286 /* [temp.deduct.call]
9288 If P is a cv-qualified type, the top level cv-qualifiers
9289 of P's type are ignored for type deduction. If P is a
9290 reference type, the type referred to by P is used for
9292 *parm = TYPE_MAIN_VARIANT (*parm);
9293 if (TREE_CODE (*parm) == REFERENCE_TYPE)
9295 *parm = TREE_TYPE (*parm);
9296 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9299 /* DR 322. For conversion deduction, remove a reference type on parm
9300 too (which has been swapped into ARG). */
9301 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
9302 *arg = TREE_TYPE (*arg);
9307 /* Most parms like fn_type_unification.
9309 If SUBR is 1, we're being called recursively (to unify the
9310 arguments of a function or method parameter of a function
9314 type_unification_real (tree tparms,
9319 unification_kind_t strict,
9320 int allow_incomplete,
9325 int ntparms = TREE_VEC_LENGTH (tparms);
9327 int saw_undeduced = 0;
9331 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
9332 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
9333 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
9334 gcc_assert (ntparms > 0);
9339 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
9340 | UNIFY_ALLOW_DERIVED);
9344 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
9348 sub_strict = UNIFY_ALLOW_NONE;
9352 sub_strict = UNIFY_ALLOW_NONE;
9368 && parms != void_list_node
9370 && args != void_list_node)
9372 parm = TREE_VALUE (parms);
9373 parms = TREE_CHAIN (parms);
9374 arg = TREE_VALUE (args);
9375 args = TREE_CHAIN (args);
9377 if (arg == error_mark_node)
9379 if (arg == unknown_type_node)
9380 /* We can't deduce anything from this, but we might get all the
9381 template args from other function args. */
9384 /* Conversions will be performed on a function argument that
9385 corresponds with a function parameter that contains only
9386 non-deducible template parameters and explicitly specified
9387 template parameters. */
9388 if (!uses_template_parms (parm))
9393 type = TREE_TYPE (arg);
9397 if (strict == DEDUCE_EXACT || strict == DEDUCE_ORDER)
9399 if (same_type_p (parm, type))
9403 /* It might work; we shouldn't check now, because we might
9404 get into infinite recursion. Overload resolution will
9413 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
9414 if (type_unknown_p (arg))
9416 /* [temp.deduct.type] A template-argument can be deduced from
9417 a pointer to function or pointer to member function
9418 argument if the set of overloaded functions does not
9419 contain function templates and at most one of a set of
9420 overloaded functions provides a unique match. */
9422 if (resolve_overloaded_unification
9423 (tparms, targs, parm, arg, strict, sub_strict)
9428 arg = TREE_TYPE (arg);
9429 if (arg == error_mark_node)
9434 int arg_strict = sub_strict;
9437 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9439 if (unify (tparms, targs, parm, arg, arg_strict))
9443 /* Are we done with the interesting parms? */
9447 /* Fail if we've reached the end of the parm list, and more args
9448 are present, and the parm list isn't variadic. */
9449 if (args && args != void_list_node && parms == void_list_node)
9451 /* Fail if parms are left and they don't have default values. */
9453 && parms != void_list_node
9454 && TREE_PURPOSE (parms) == NULL_TREE)
9459 for (i = 0; i < ntparms; i++)
9460 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
9462 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
9464 /* If this is an undeduced nontype parameter that depends on
9465 a type parameter, try another pass; its type may have been
9466 deduced from a later argument than the one from which
9467 this parameter can be deduced. */
9468 if (TREE_CODE (tparm) == PARM_DECL
9469 && uses_template_parms (TREE_TYPE (tparm))
9470 && !saw_undeduced++)
9473 if (!allow_incomplete)
9474 error ("incomplete type unification");
9480 /* Subroutine of type_unification_real. Args are like the variables at the
9481 call site. ARG is an overloaded function (or template-id); we try
9482 deducing template args from each of the overloads, and if only one
9483 succeeds, we go with that. Modifies TARGS and returns 0 on success. */
9486 resolve_overloaded_unification (tree tparms,
9490 unification_kind_t strict,
9493 tree tempargs = copy_node (targs);
9497 if (TREE_CODE (arg) == ADDR_EXPR)
9499 arg = TREE_OPERAND (arg, 0);
9505 if (TREE_CODE (arg) == COMPONENT_REF)
9506 /* Handle `&x' where `x' is some static or non-static member
9508 arg = TREE_OPERAND (arg, 1);
9510 if (TREE_CODE (arg) == OFFSET_REF)
9511 arg = TREE_OPERAND (arg, 1);
9513 /* Strip baselink information. */
9514 if (BASELINK_P (arg))
9515 arg = BASELINK_FUNCTIONS (arg);
9517 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
9519 /* If we got some explicit template args, we need to plug them into
9520 the affected templates before we try to unify, in case the
9521 explicit args will completely resolve the templates in question. */
9523 tree expl_subargs = TREE_OPERAND (arg, 1);
9524 arg = TREE_OPERAND (arg, 0);
9526 for (; arg; arg = OVL_NEXT (arg))
9528 tree fn = OVL_CURRENT (arg);
9531 if (TREE_CODE (fn) != TEMPLATE_DECL)
9534 subargs = get_bindings_overload (fn, DECL_TEMPLATE_RESULT (fn),
9538 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
9539 good += try_one_overload (tparms, targs, tempargs, parm,
9540 elem, strict, sub_strict, addr_p);
9546 gcc_assert (TREE_CODE (arg) == OVERLOAD
9547 || TREE_CODE (arg) == FUNCTION_DECL);
9549 for (; arg; arg = OVL_NEXT (arg))
9550 good += try_one_overload (tparms, targs, tempargs, parm,
9551 TREE_TYPE (OVL_CURRENT (arg)),
9552 strict, sub_strict, addr_p);
9555 /* [temp.deduct.type] A template-argument can be deduced from a pointer
9556 to function or pointer to member function argument if the set of
9557 overloaded functions does not contain function templates and at most
9558 one of a set of overloaded functions provides a unique match.
9560 So if we found multiple possibilities, we return success but don't
9565 int i = TREE_VEC_LENGTH (targs);
9567 if (TREE_VEC_ELT (tempargs, i))
9568 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
9576 /* Subroutine of resolve_overloaded_unification; does deduction for a single
9577 overload. Fills TARGS with any deduced arguments, or error_mark_node if
9578 different overloads deduce different arguments for a given parm.
9579 ADDR_P is true if the expression for which deduction is being
9580 performed was of the form "& fn" rather than simply "fn".
9582 Returns 1 on success. */
9585 try_one_overload (tree tparms,
9590 unification_kind_t strict,
9598 /* [temp.deduct.type] A template-argument can be deduced from a pointer
9599 to function or pointer to member function argument if the set of
9600 overloaded functions does not contain function templates and at most
9601 one of a set of overloaded functions provides a unique match.
9603 So if this is a template, just return success. */
9605 if (uses_template_parms (arg))
9608 if (TREE_CODE (arg) == METHOD_TYPE)
9609 arg = build_ptrmemfunc_type (build_pointer_type (arg));
9611 arg = build_pointer_type (arg);
9613 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
9615 /* We don't copy orig_targs for this because if we have already deduced
9616 some template args from previous args, unify would complain when we
9617 try to deduce a template parameter for the same argument, even though
9618 there isn't really a conflict. */
9619 nargs = TREE_VEC_LENGTH (targs);
9620 tempargs = make_tree_vec (nargs);
9622 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
9625 /* First make sure we didn't deduce anything that conflicts with
9626 explicitly specified args. */
9627 for (i = nargs; i--; )
9629 tree elt = TREE_VEC_ELT (tempargs, i);
9630 tree oldelt = TREE_VEC_ELT (orig_targs, i);
9632 if (elt == NULL_TREE)
9634 else if (uses_template_parms (elt))
9636 /* Since we're unifying against ourselves, we will fill in template
9637 args used in the function parm list with our own template parms.
9639 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
9642 else if (oldelt && ! template_args_equal (oldelt, elt))
9646 for (i = nargs; i--; )
9648 tree elt = TREE_VEC_ELT (tempargs, i);
9651 TREE_VEC_ELT (targs, i) = elt;
9657 /* Verify that nondeduce template argument agrees with the type
9658 obtained from argument deduction. Return nonzero if the
9663 struct A { typedef int X; };
9664 template <class T, class U> struct C {};
9665 template <class T> struct C<T, typename T::X> {};
9667 Then with the instantiation `C<A, int>', we can deduce that
9668 `T' is `A' but unify () does not check whether `typename T::X'
9669 is `int'. This function ensure that they agree.
9671 TARGS, PARMS are the same as the arguments of unify.
9672 ARGS contains template arguments from all levels. */
9675 verify_class_unification (tree targs, tree parms, tree args)
9677 parms = tsubst (parms, add_outermost_template_args (args, targs),
9678 tf_none, NULL_TREE);
9679 if (parms == error_mark_node)
9682 return !comp_template_args (parms, INNERMOST_TEMPLATE_ARGS (args));
9685 /* PARM is a template class (perhaps with unbound template
9686 parameters). ARG is a fully instantiated type. If ARG can be
9687 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
9688 TARGS are as for unify. */
9691 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
9695 if (!CLASSTYPE_TEMPLATE_INFO (arg)
9696 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
9697 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
9700 /* We need to make a new template argument vector for the call to
9701 unify. If we used TARGS, we'd clutter it up with the result of
9702 the attempted unification, even if this class didn't work out.
9703 We also don't want to commit ourselves to all the unifications
9704 we've already done, since unification is supposed to be done on
9705 an argument-by-argument basis. In other words, consider the
9706 following pathological case:
9708 template <int I, int J, int K>
9711 template <int I, int J>
9712 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
9714 template <int I, int J, int K>
9715 void f(S<I, J, K>, S<I, I, I>);
9724 Now, by the time we consider the unification involving `s2', we
9725 already know that we must have `f<0, 0, 0>'. But, even though
9726 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
9727 because there are two ways to unify base classes of S<0, 1, 2>
9728 with S<I, I, I>. If we kept the already deduced knowledge, we
9729 would reject the possibility I=1. */
9730 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
9732 /* If unification failed, we're done. */
9733 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
9734 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
9740 /* Given a template type PARM and a class type ARG, find the unique
9741 base type in ARG that is an instance of PARM. We do not examine
9742 ARG itself; only its base-classes. If there is not exactly one
9743 appropriate base class, return NULL_TREE. PARM may be the type of
9744 a partial specialization, as well as a plain template type. Used
9748 get_template_base (tree tparms, tree targs, tree parm, tree arg)
9750 tree rval = NULL_TREE;
9753 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
9755 binfo = TYPE_BINFO (complete_type (arg));
9757 /* The type could not be completed. */
9760 /* Walk in inheritance graph order. The search order is not
9761 important, and this avoids multiple walks of virtual bases. */
9762 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
9764 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
9768 /* If there is more than one satisfactory baseclass, then:
9772 If they yield more than one possible deduced A, the type
9776 if (rval && !same_type_p (r, rval))
9786 /* Returns the level of DECL, which declares a template parameter. */
9789 template_decl_level (tree decl)
9791 switch (TREE_CODE (decl))
9795 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
9798 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
9806 /* Decide whether ARG can be unified with PARM, considering only the
9807 cv-qualifiers of each type, given STRICT as documented for unify.
9808 Returns nonzero iff the unification is OK on that basis. */
9811 check_cv_quals_for_unify (int strict, tree arg, tree parm)
9813 int arg_quals = cp_type_quals (arg);
9814 int parm_quals = cp_type_quals (parm);
9816 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
9817 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
9819 /* Although a CVR qualifier is ignored when being applied to a
9820 substituted template parameter ([8.3.2]/1 for example), that
9821 does not apply during deduction [14.8.2.4]/1, (even though
9822 that is not explicitly mentioned, [14.8.2.4]/9 indicates
9823 this). Except when we're allowing additional CV qualifiers
9824 at the outer level [14.8.2.1]/3,1st bullet. */
9825 if ((TREE_CODE (arg) == REFERENCE_TYPE
9826 || TREE_CODE (arg) == FUNCTION_TYPE
9827 || TREE_CODE (arg) == METHOD_TYPE)
9828 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
9831 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
9832 && (parm_quals & TYPE_QUAL_RESTRICT))
9836 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
9837 && (arg_quals & parm_quals) != parm_quals)
9840 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
9841 && (parm_quals & arg_quals) != arg_quals)
9847 /* Takes parameters as for type_unification. Returns 0 if the
9848 type deduction succeeds, 1 otherwise. The parameter STRICT is a
9849 bitwise or of the following flags:
9852 Require an exact match between PARM and ARG.
9853 UNIFY_ALLOW_MORE_CV_QUAL:
9854 Allow the deduced ARG to be more cv-qualified (by qualification
9855 conversion) than ARG.
9856 UNIFY_ALLOW_LESS_CV_QUAL:
9857 Allow the deduced ARG to be less cv-qualified than ARG.
9858 UNIFY_ALLOW_DERIVED:
9859 Allow the deduced ARG to be a template base class of ARG,
9860 or a pointer to a template base class of the type pointed to by
9862 UNIFY_ALLOW_INTEGER:
9863 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
9864 case for more information.
9865 UNIFY_ALLOW_OUTER_LEVEL:
9866 This is the outermost level of a deduction. Used to determine validity
9867 of qualification conversions. A valid qualification conversion must
9868 have const qualified pointers leading up to the inner type which
9869 requires additional CV quals, except at the outer level, where const
9870 is not required [conv.qual]. It would be normal to set this flag in
9871 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
9872 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
9873 This is the outermost level of a deduction, and PARM can be more CV
9874 qualified at this point.
9875 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
9876 This is the outermost level of a deduction, and PARM can be less CV
9877 qualified at this point. */
9880 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
9885 int strict_in = strict;
9887 /* I don't think this will do the right thing with respect to types.
9888 But the only case I've seen it in so far has been array bounds, where
9889 signedness is the only information lost, and I think that will be
9891 while (TREE_CODE (parm) == NOP_EXPR)
9892 parm = TREE_OPERAND (parm, 0);
9894 if (arg == error_mark_node)
9896 if (arg == unknown_type_node)
9897 /* We can't deduce anything from this, but we might get all the
9898 template args from other function args. */
9901 /* If PARM uses template parameters, then we can't bail out here,
9902 even if ARG == PARM, since we won't record unifications for the
9903 template parameters. We might need them if we're trying to
9904 figure out which of two things is more specialized. */
9905 if (arg == parm && !uses_template_parms (parm))
9908 /* Immediately reject some pairs that won't unify because of
9909 cv-qualification mismatches. */
9910 if (TREE_CODE (arg) == TREE_CODE (parm)
9912 /* It is the elements of the array which hold the cv quals of an array
9913 type, and the elements might be template type parms. We'll check
9915 && TREE_CODE (arg) != ARRAY_TYPE
9916 /* We check the cv-qualifiers when unifying with template type
9917 parameters below. We want to allow ARG `const T' to unify with
9918 PARM `T' for example, when computing which of two templates
9919 is more specialized, for example. */
9920 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
9921 && !check_cv_quals_for_unify (strict_in, arg, parm))
9924 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
9925 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
9926 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
9927 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
9928 strict &= ~UNIFY_ALLOW_DERIVED;
9929 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
9930 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
9932 switch (TREE_CODE (parm))
9936 case UNBOUND_CLASS_TEMPLATE:
9937 /* In a type which contains a nested-name-specifier, template
9938 argument values cannot be deduced for template parameters used
9939 within the nested-name-specifier. */
9942 case TEMPLATE_TYPE_PARM:
9943 case TEMPLATE_TEMPLATE_PARM:
9944 case BOUND_TEMPLATE_TEMPLATE_PARM:
9945 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
9947 if (TEMPLATE_TYPE_LEVEL (parm)
9948 != template_decl_level (tparm))
9949 /* The PARM is not one we're trying to unify. Just check
9950 to see if it matches ARG. */
9951 return (TREE_CODE (arg) == TREE_CODE (parm)
9952 && same_type_p (parm, arg)) ? 0 : 1;
9953 idx = TEMPLATE_TYPE_IDX (parm);
9954 targ = TREE_VEC_ELT (targs, idx);
9955 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
9957 /* Check for mixed types and values. */
9958 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
9959 && TREE_CODE (tparm) != TYPE_DECL)
9960 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
9961 && TREE_CODE (tparm) != TEMPLATE_DECL))
9964 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
9966 /* ARG must be constructed from a template class or a template
9967 template parameter. */
9968 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
9969 && (TREE_CODE (arg) != RECORD_TYPE || !CLASSTYPE_TEMPLATE_INFO (arg)))
9973 tree parmtmpl = TYPE_TI_TEMPLATE (parm);
9974 tree parmvec = TYPE_TI_ARGS (parm);
9975 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
9977 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
9980 /* The parameter and argument roles have to be switched here
9981 in order to handle default arguments properly. For example,
9982 template<template <class> class TT> void f(TT<int>)
9983 should be able to accept vector<int> which comes from
9984 template <class T, class Allocator = allocator>
9987 if (coerce_template_parms (argtmplvec, parmvec, parmtmpl, 0, 1)
9991 /* Deduce arguments T, i from TT<T> or TT<i>.
9992 We check each element of PARMVEC and ARGVEC individually
9993 rather than the whole TREE_VEC since they can have
9994 different number of elements. */
9996 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
9998 if (unify (tparms, targs,
9999 TREE_VEC_ELT (parmvec, i),
10000 TREE_VEC_ELT (argvec, i),
10005 arg = TYPE_TI_TEMPLATE (arg);
10007 /* Fall through to deduce template name. */
10010 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
10011 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
10013 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
10015 /* Simple cases: Value already set, does match or doesn't. */
10016 if (targ != NULL_TREE && template_args_equal (targ, arg))
10023 /* If PARM is `const T' and ARG is only `int', we don't have
10024 a match unless we are allowing additional qualification.
10025 If ARG is `const int' and PARM is just `T' that's OK;
10026 that binds `const int' to `T'. */
10027 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
10031 /* Consider the case where ARG is `const volatile int' and
10032 PARM is `const T'. Then, T should be `volatile int'. */
10033 arg = cp_build_qualified_type_real
10034 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
10035 if (arg == error_mark_node)
10038 /* Simple cases: Value already set, does match or doesn't. */
10039 if (targ != NULL_TREE && same_type_p (targ, arg))
10044 /* Make sure that ARG is not a variable-sized array. (Note
10045 that were talking about variable-sized arrays (like
10046 `int[n]'), rather than arrays of unknown size (like
10047 `int[]').) We'll get very confused by such a type since
10048 the bound of the array will not be computable in an
10049 instantiation. Besides, such types are not allowed in
10050 ISO C++, so we can do as we please here. */
10051 if (variably_modified_type_p (arg, NULL_TREE))
10055 TREE_VEC_ELT (targs, idx) = arg;
10058 case TEMPLATE_PARM_INDEX:
10059 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
10061 if (TEMPLATE_PARM_LEVEL (parm)
10062 != template_decl_level (tparm))
10063 /* The PARM is not one we're trying to unify. Just check
10064 to see if it matches ARG. */
10065 return !(TREE_CODE (arg) == TREE_CODE (parm)
10066 && cp_tree_equal (parm, arg));
10068 idx = TEMPLATE_PARM_IDX (parm);
10069 targ = TREE_VEC_ELT (targs, idx);
10072 return !cp_tree_equal (targ, arg);
10074 /* [temp.deduct.type] If, in the declaration of a function template
10075 with a non-type template-parameter, the non-type
10076 template-parameter is used in an expression in the function
10077 parameter-list and, if the corresponding template-argument is
10078 deduced, the template-argument type shall match the type of the
10079 template-parameter exactly, except that a template-argument
10080 deduced from an array bound may be of any integral type.
10081 The non-type parameter might use already deduced type parameters. */
10082 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
10083 if (!TREE_TYPE (arg))
10084 /* Template-parameter dependent expression. Just accept it for now.
10085 It will later be processed in convert_template_argument. */
10087 else if (same_type_p (TREE_TYPE (arg), tparm))
10089 else if ((strict & UNIFY_ALLOW_INTEGER)
10090 && (TREE_CODE (tparm) == INTEGER_TYPE
10091 || TREE_CODE (tparm) == BOOLEAN_TYPE))
10092 /* Convert the ARG to the type of PARM; the deduced non-type
10093 template argument must exactly match the types of the
10094 corresponding parameter. */
10095 arg = fold (build_nop (TREE_TYPE (parm), arg));
10096 else if (uses_template_parms (tparm))
10097 /* We haven't deduced the type of this parameter yet. Try again
10103 TREE_VEC_ELT (targs, idx) = arg;
10108 /* A pointer-to-member constant can be unified only with
10109 another constant. */
10110 if (TREE_CODE (arg) != PTRMEM_CST)
10113 /* Just unify the class member. It would be useless (and possibly
10114 wrong, depending on the strict flags) to unify also
10115 PTRMEM_CST_CLASS, because we want to be sure that both parm and
10116 arg refer to the same variable, even if through different
10117 classes. For instance:
10119 struct A { int x; };
10122 Unification of &A::x and &B::x must succeed. */
10123 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
10124 PTRMEM_CST_MEMBER (arg), strict);
10129 if (TREE_CODE (arg) != POINTER_TYPE)
10132 /* [temp.deduct.call]
10134 A can be another pointer or pointer to member type that can
10135 be converted to the deduced A via a qualification
10136 conversion (_conv.qual_).
10138 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
10139 This will allow for additional cv-qualification of the
10140 pointed-to types if appropriate. */
10142 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
10143 /* The derived-to-base conversion only persists through one
10144 level of pointers. */
10145 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
10147 return unify (tparms, targs, TREE_TYPE (parm),
10148 TREE_TYPE (arg), strict);
10151 case REFERENCE_TYPE:
10152 if (TREE_CODE (arg) != REFERENCE_TYPE)
10154 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10155 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10158 if (TREE_CODE (arg) != ARRAY_TYPE)
10160 if ((TYPE_DOMAIN (parm) == NULL_TREE)
10161 != (TYPE_DOMAIN (arg) == NULL_TREE))
10163 if (TYPE_DOMAIN (parm) != NULL_TREE)
10168 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
10169 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
10171 /* Our representation of array types uses "N - 1" as the
10172 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
10173 not an integer constant. */
10174 if (TREE_CODE (parm_max) == MINUS_EXPR)
10176 arg_max = fold (build2 (PLUS_EXPR,
10179 TREE_OPERAND (parm_max, 1)));
10180 parm_max = TREE_OPERAND (parm_max, 0);
10183 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
10186 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10187 strict & UNIFY_ALLOW_MORE_CV_QUAL);
10194 case ENUMERAL_TYPE:
10196 if (TREE_CODE (arg) != TREE_CODE (parm))
10199 /* We have already checked cv-qualification at the top of the
10201 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
10204 /* As far as unification is concerned, this wins. Later checks
10205 will invalidate it if necessary. */
10208 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
10209 /* Type INTEGER_CST can come from ordinary constant template args. */
10211 while (TREE_CODE (arg) == NOP_EXPR)
10212 arg = TREE_OPERAND (arg, 0);
10214 if (TREE_CODE (arg) != INTEGER_CST)
10216 return !tree_int_cst_equal (parm, arg);
10221 if (TREE_CODE (arg) != TREE_VEC)
10223 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
10225 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
10226 if (unify (tparms, targs,
10227 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
10235 if (TREE_CODE (arg) != TREE_CODE (parm))
10238 if (TYPE_PTRMEMFUNC_P (parm))
10240 if (!TYPE_PTRMEMFUNC_P (arg))
10243 return unify (tparms, targs,
10244 TYPE_PTRMEMFUNC_FN_TYPE (parm),
10245 TYPE_PTRMEMFUNC_FN_TYPE (arg),
10249 if (CLASSTYPE_TEMPLATE_INFO (parm))
10251 tree t = NULL_TREE;
10253 if (strict_in & UNIFY_ALLOW_DERIVED)
10255 /* First, we try to unify the PARM and ARG directly. */
10256 t = try_class_unification (tparms, targs,
10261 /* Fallback to the special case allowed in
10262 [temp.deduct.call]:
10264 If P is a class, and P has the form
10265 template-id, then A can be a derived class of
10266 the deduced A. Likewise, if P is a pointer to
10267 a class of the form template-id, A can be a
10268 pointer to a derived class pointed to by the
10270 t = get_template_base (tparms, targs, parm, arg);
10276 else if (CLASSTYPE_TEMPLATE_INFO (arg)
10277 && (CLASSTYPE_TI_TEMPLATE (parm)
10278 == CLASSTYPE_TI_TEMPLATE (arg)))
10279 /* Perhaps PARM is something like S<U> and ARG is S<int>.
10280 Then, we should unify `int' and `U'. */
10283 /* There's no chance of unification succeeding. */
10286 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
10287 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
10289 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
10294 case FUNCTION_TYPE:
10295 if (TREE_CODE (arg) != TREE_CODE (parm))
10298 if (unify (tparms, targs, TREE_TYPE (parm),
10299 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
10301 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
10302 TYPE_ARG_TYPES (arg), 1,
10303 DEDUCE_EXACT, 0, -1);
10306 /* Unify a pointer to member with a pointer to member function, which
10307 deduces the type of the member as a function type. */
10308 if (TYPE_PTRMEMFUNC_P (arg))
10312 cp_cv_quals cv_quals;
10314 /* Check top-level cv qualifiers */
10315 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
10318 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10319 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
10322 /* Determine the type of the function we are unifying against. */
10323 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
10325 build_function_type (TREE_TYPE (method_type),
10326 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
10328 /* Extract the cv-qualifiers of the member function from the
10329 implicit object parameter and place them on the function
10330 type to be restored later. */
10332 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
10333 fntype = build_qualified_type (fntype, cv_quals);
10334 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
10337 if (TREE_CODE (arg) != OFFSET_TYPE)
10339 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
10340 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
10342 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
10346 if (DECL_TEMPLATE_PARM_P (parm))
10347 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
10348 if (arg != integral_constant_value (parm))
10353 case TEMPLATE_DECL:
10354 /* Matched cases are handled by the ARG == PARM test above. */
10358 gcc_assert (EXPR_P (parm));
10360 /* We must be looking at an expression. This can happen with
10364 void foo(S<I>, S<I + 2>);
10366 This is a "nondeduced context":
10370 The nondeduced contexts are:
10372 --A type that is a template-id in which one or more of
10373 the template-arguments is an expression that references
10374 a template-parameter.
10376 In these cases, we assume deduction succeeded, but don't
10377 actually infer any unifications. */
10379 if (!uses_template_parms (parm)
10380 && !template_args_equal (parm, arg))
10387 /* Note that DECL can be defined in this translation unit, if
10391 mark_definable (tree decl)
10394 DECL_NOT_REALLY_EXTERN (decl) = 1;
10395 FOR_EACH_CLONE (clone, decl)
10396 DECL_NOT_REALLY_EXTERN (clone) = 1;
10399 /* Called if RESULT is explicitly instantiated, or is a member of an
10400 explicitly instantiated class. */
10403 mark_decl_instantiated (tree result, int extern_p)
10405 SET_DECL_EXPLICIT_INSTANTIATION (result);
10407 /* If this entity has already been written out, it's too late to
10408 make any modifications. */
10409 if (TREE_ASM_WRITTEN (result))
10412 if (TREE_CODE (result) != FUNCTION_DECL)
10413 /* The TREE_PUBLIC flag for function declarations will have been
10414 set correctly by tsubst. */
10415 TREE_PUBLIC (result) = 1;
10417 /* This might have been set by an earlier implicit instantiation. */
10418 DECL_COMDAT (result) = 0;
10421 DECL_NOT_REALLY_EXTERN (result) = 0;
10424 mark_definable (result);
10425 /* Always make artificials weak. */
10426 if (DECL_ARTIFICIAL (result) && flag_weak)
10427 comdat_linkage (result);
10428 /* For WIN32 we also want to put explicit instantiations in
10429 linkonce sections. */
10430 else if (TREE_PUBLIC (result))
10431 maybe_make_one_only (result);
10434 /* If EXTERN_P, then this function will not be emitted -- unless
10435 followed by an explicit instantiation, at which point its linkage
10436 will be adjusted. If !EXTERN_P, then this function will be
10437 emitted here. In neither circumstance do we want
10438 import_export_decl to adjust the linkage. */
10439 DECL_INTERFACE_KNOWN (result) = 1;
10442 /* Given two function templates PAT1 and PAT2, return:
10444 DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER.
10446 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
10447 -1 if PAT2 is more specialized than PAT1.
10448 0 if neither is more specialized.
10450 LEN is passed through to fn_type_unification. */
10453 more_specialized (tree pat1, tree pat2, int deduce, int len)
10458 /* If template argument deduction succeeds, we substitute the
10459 resulting arguments into non-deduced contexts. While doing that,
10460 we must be aware that we may encounter dependent types. */
10461 ++processing_template_decl;
10462 targs = get_bindings_real (pat1, DECL_TEMPLATE_RESULT (pat2),
10463 NULL_TREE, 0, deduce, len);
10467 targs = get_bindings_real (pat2, DECL_TEMPLATE_RESULT (pat1),
10468 NULL_TREE, 0, deduce, len);
10471 --processing_template_decl;
10476 /* Given two class template specialization list nodes PAT1 and PAT2, return:
10478 1 if PAT1 is more specialized than PAT2 as described in [temp.class.order].
10479 -1 if PAT2 is more specialized than PAT1.
10480 0 if neither is more specialized.
10482 FULL_ARGS is the full set of template arguments that triggers this
10483 partial ordering. */
10486 more_specialized_class (tree pat1, tree pat2, tree full_args)
10491 /* Just like what happens for functions, if we are ordering between
10492 different class template specializations, we may encounter dependent
10493 types in the arguments, and we need our dependency check functions
10494 to behave correctly. */
10495 ++processing_template_decl;
10496 targs = get_class_bindings (TREE_VALUE (pat1), TREE_PURPOSE (pat1),
10497 add_outermost_template_args (full_args, TREE_PURPOSE (pat2)));
10501 targs = get_class_bindings (TREE_VALUE (pat2), TREE_PURPOSE (pat2),
10502 add_outermost_template_args (full_args, TREE_PURPOSE (pat1)));
10505 --processing_template_decl;
10510 /* Return the template arguments that will produce the function signature
10511 DECL from the function template FN, with the explicit template
10512 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is 1, the return type must
10513 also match. Return NULL_TREE if no satisfactory arguments could be
10514 found. DEDUCE and LEN are passed through to fn_type_unification. */
10517 get_bindings_real (tree fn,
10519 tree explicit_args,
10524 int ntparms = DECL_NTPARMS (fn);
10525 tree targs = make_tree_vec (ntparms);
10527 tree decl_arg_types;
10530 /* Substitute the explicit template arguments into the type of DECL.
10531 The call to fn_type_unification will handle substitution into the
10533 decl_type = TREE_TYPE (decl);
10534 if (explicit_args && uses_template_parms (decl_type))
10537 tree converted_args;
10539 if (DECL_TEMPLATE_INFO (decl))
10540 tmpl = DECL_TI_TEMPLATE (decl);
10542 /* We can get here for some invalid specializations. */
10546 = (coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
10547 explicit_args, NULL_TREE,
10548 tf_none, /*require_all_arguments=*/0));
10549 if (converted_args == error_mark_node)
10552 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
10553 if (decl_type == error_mark_node)
10557 decl_arg_types = TYPE_ARG_TYPES (decl_type);
10558 /* Never do unification on the 'this' parameter. */
10559 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
10560 decl_arg_types = TREE_CHAIN (decl_arg_types);
10562 i = fn_type_unification (fn, explicit_args, targs,
10564 (check_rettype || DECL_CONV_FN_P (fn)
10565 ? TREE_TYPE (decl_type) : NULL_TREE),
10574 /* For most uses, we want to check the return type. */
10577 get_bindings (tree fn, tree decl, tree explicit_args)
10579 return get_bindings_real (fn, decl, explicit_args, 1, DEDUCE_EXACT, -1);
10582 /* But for resolve_overloaded_unification, we only care about the parameter
10586 get_bindings_overload (tree fn, tree decl, tree explicit_args)
10588 return get_bindings_real (fn, decl, explicit_args, 0, DEDUCE_EXACT, -1);
10591 /* Return the innermost template arguments that, when applied to a
10592 template specialization whose innermost template parameters are
10593 TPARMS, and whose specialization arguments are PARMS, yield the
10596 For example, suppose we have:
10598 template <class T, class U> struct S {};
10599 template <class T> struct S<T*, int> {};
10601 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
10602 {T}, the PARMS will be {T*, int} and the ARGS will be {double*,
10603 int}. The resulting vector will be {double}, indicating that `T'
10604 is bound to `double'. */
10607 get_class_bindings (tree tparms, tree parms, tree args)
10609 int i, ntparms = TREE_VEC_LENGTH (tparms);
10610 tree vec = make_tree_vec (ntparms);
10612 if (unify (tparms, vec, parms, INNERMOST_TEMPLATE_ARGS (args),
10616 for (i = 0; i < ntparms; ++i)
10617 if (! TREE_VEC_ELT (vec, i))
10620 if (verify_class_unification (vec, parms, args))
10626 /* In INSTANTIATIONS is a list of <INSTANTIATION, TEMPLATE> pairs.
10627 Pick the most specialized template, and return the corresponding
10628 instantiation, or if there is no corresponding instantiation, the
10629 template itself. If there is no most specialized template,
10630 error_mark_node is returned. If there are no templates at all,
10631 NULL_TREE is returned. */
10634 most_specialized_instantiation (tree instantiations)
10639 if (!instantiations)
10642 champ = instantiations;
10643 for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn))
10645 fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn),
10653 fn = TREE_CHAIN (fn);
10655 return error_mark_node;
10661 for (fn = instantiations; fn && fn != champ; fn = TREE_CHAIN (fn))
10663 fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn),
10666 return error_mark_node;
10669 return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ);
10672 /* Return the most specialized of the list of templates in FNS that can
10673 produce an instantiation matching DECL, given the explicit template
10674 arguments EXPLICIT_ARGS. */
10677 most_specialized (tree fns, tree decl, tree explicit_args)
10679 tree candidates = NULL_TREE;
10682 for (fn = fns; fn; fn = TREE_CHAIN (fn))
10684 tree candidate = TREE_VALUE (fn);
10686 args = get_bindings (candidate, decl, explicit_args);
10688 candidates = tree_cons (NULL_TREE, candidate, candidates);
10691 return most_specialized_instantiation (candidates);
10694 /* If DECL is a specialization of some template, return the most
10695 general such template. Otherwise, returns NULL_TREE.
10697 For example, given:
10699 template <class T> struct S { template <class U> void f(U); };
10701 if TMPL is `template <class U> void S<int>::f(U)' this will return
10702 the full template. This function will not trace past partial
10703 specializations, however. For example, given in addition:
10705 template <class T> struct S<T*> { template <class U> void f(U); };
10707 if TMPL is `template <class U> void S<int*>::f(U)' this will return
10708 `template <class T> template <class U> S<T*>::f(U)'. */
10711 most_general_template (tree decl)
10713 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
10714 an immediate specialization. */
10715 if (TREE_CODE (decl) == FUNCTION_DECL)
10717 if (DECL_TEMPLATE_INFO (decl)) {
10718 decl = DECL_TI_TEMPLATE (decl);
10720 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
10721 template friend. */
10722 if (TREE_CODE (decl) != TEMPLATE_DECL)
10728 /* Look for more and more general templates. */
10729 while (DECL_TEMPLATE_INFO (decl))
10731 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
10732 (See cp-tree.h for details.) */
10733 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
10736 if (CLASS_TYPE_P (TREE_TYPE (decl))
10737 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
10740 /* Stop if we run into an explicitly specialized class template. */
10741 if (!DECL_NAMESPACE_SCOPE_P (decl)
10742 && DECL_CONTEXT (decl)
10743 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
10746 decl = DECL_TI_TEMPLATE (decl);
10752 /* Return the most specialized of the class template specializations
10753 of TMPL which can produce an instantiation matching ARGS, or
10754 error_mark_node if the choice is ambiguous. */
10757 most_specialized_class (tree tmpl, tree args)
10759 tree list = NULL_TREE;
10764 tmpl = most_general_template (tmpl);
10765 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
10768 = get_class_bindings (TREE_VALUE (t), TREE_PURPOSE (t), args);
10771 list = tree_cons (TREE_PURPOSE (t), TREE_VALUE (t), list);
10772 TREE_TYPE (list) = TREE_TYPE (t);
10781 t = TREE_CHAIN (t);
10782 for (; t; t = TREE_CHAIN (t))
10784 fate = more_specialized_class (champ, t, args);
10791 t = TREE_CHAIN (t);
10793 return error_mark_node;
10799 for (t = list; t && t != champ; t = TREE_CHAIN (t))
10801 fate = more_specialized_class (champ, t, args);
10803 return error_mark_node;
10809 /* Explicitly instantiate DECL. */
10812 do_decl_instantiation (tree decl, tree storage)
10814 tree result = NULL_TREE;
10818 /* An error occurred, for which grokdeclarator has already issued
10819 an appropriate message. */
10821 else if (! DECL_LANG_SPECIFIC (decl))
10823 error ("explicit instantiation of non-template %q#D", decl);
10826 else if (TREE_CODE (decl) == VAR_DECL)
10828 /* There is an asymmetry here in the way VAR_DECLs and
10829 FUNCTION_DECLs are handled by grokdeclarator. In the case of
10830 the latter, the DECL we get back will be marked as a
10831 template instantiation, and the appropriate
10832 DECL_TEMPLATE_INFO will be set up. This does not happen for
10833 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
10834 should handle VAR_DECLs as it currently handles
10836 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
10837 if (!result || TREE_CODE (result) != VAR_DECL)
10839 error ("no matching template for %qD found", decl);
10843 else if (TREE_CODE (decl) != FUNCTION_DECL)
10845 error ("explicit instantiation of %q#D", decl);
10851 /* Check for various error cases. Note that if the explicit
10852 instantiation is valid the RESULT will currently be marked as an
10853 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
10854 until we get here. */
10856 if (DECL_TEMPLATE_SPECIALIZATION (result))
10858 /* DR 259 [temp.spec].
10860 Both an explicit instantiation and a declaration of an explicit
10861 specialization shall not appear in a program unless the explicit
10862 instantiation follows a declaration of the explicit specialization.
10864 For a given set of template parameters, if an explicit
10865 instantiation of a template appears after a declaration of an
10866 explicit specialization for that template, the explicit
10867 instantiation has no effect. */
10870 else if (DECL_EXPLICIT_INSTANTIATION (result))
10874 No program shall explicitly instantiate any template more
10877 We check DECL_NOT_REALLY_EXTERN so as not to complain when
10878 the first instantiation was `extern' and the second is not,
10879 and EXTERN_P for the opposite case. */
10880 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
10881 pedwarn ("duplicate explicit instantiation of %q#D", result);
10882 /* If an "extern" explicit instantiation follows an ordinary
10883 explicit instantiation, the template is instantiated. */
10887 else if (!DECL_IMPLICIT_INSTANTIATION (result))
10889 error ("no matching template for %qD found", result);
10892 else if (!DECL_TEMPLATE_INFO (result))
10894 pedwarn ("explicit instantiation of non-template %q#D", result);
10898 if (storage == NULL_TREE)
10900 else if (storage == ridpointers[(int) RID_EXTERN])
10902 if (pedantic && !in_system_header)
10903 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
10908 error ("storage class %qD applied to template instantiation", storage);
10910 mark_decl_instantiated (result, extern_p);
10912 instantiate_decl (result, /*defer_ok=*/1, /*undefined_ok=*/0);
10916 mark_class_instantiated (tree t, int extern_p)
10918 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
10919 SET_CLASSTYPE_INTERFACE_KNOWN (t);
10920 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
10921 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
10924 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
10925 rest_of_type_compilation (t, 1);
10929 /* Called from do_type_instantiation through binding_table_foreach to
10930 do recursive instantiation for the type bound in ENTRY. */
10932 bt_instantiate_type_proc (binding_entry entry, void *data)
10934 tree storage = *(tree *) data;
10936 if (IS_AGGR_TYPE (entry->type)
10937 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
10938 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
10941 /* Called from do_type_instantiation to instantiate a member
10942 (a member function or a static member variable) of an
10943 explicitly instantiated class template. */
10945 instantiate_class_member (tree decl, int extern_p)
10947 mark_decl_instantiated (decl, extern_p);
10949 instantiate_decl (decl, /*defer_ok=*/1, /* undefined_ok=*/1);
10952 /* Perform an explicit instantiation of template class T. STORAGE, if
10953 non-null, is the RID for extern, inline or static. COMPLAIN is
10954 nonzero if this is called from the parser, zero if called recursively,
10955 since the standard is unclear (as detailed below). */
10958 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
10963 int previous_instantiation_extern_p = 0;
10965 if (TREE_CODE (t) == TYPE_DECL)
10968 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
10970 error ("explicit instantiation of non-template type %qT", t);
10976 if (!COMPLETE_TYPE_P (t))
10978 if (complain & tf_error)
10979 error ("explicit instantiation of %q#T before definition of template",
10984 if (storage != NULL_TREE)
10986 if (pedantic && !in_system_header)
10987 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
10990 if (storage == ridpointers[(int) RID_INLINE])
10992 else if (storage == ridpointers[(int) RID_EXTERN])
10994 else if (storage == ridpointers[(int) RID_STATIC])
10998 error ("storage class %qD applied to template instantiation",
11004 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
11006 /* DR 259 [temp.spec].
11008 Both an explicit instantiation and a declaration of an explicit
11009 specialization shall not appear in a program unless the explicit
11010 instantiation follows a declaration of the explicit specialization.
11012 For a given set of template parameters, if an explicit
11013 instantiation of a template appears after a declaration of an
11014 explicit specialization for that template, the explicit
11015 instantiation has no effect. */
11018 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
11022 No program shall explicitly instantiate any template more
11025 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
11026 instantiation was `extern'. If EXTERN_P then the second is.
11027 These cases are OK. */
11028 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
11030 if (!previous_instantiation_extern_p && !extern_p
11031 && (complain & tf_error))
11032 pedwarn ("duplicate explicit instantiation of %q#T", t);
11034 /* If we've already instantiated the template, just return now. */
11035 if (!CLASSTYPE_INTERFACE_ONLY (t))
11039 mark_class_instantiated (t, extern_p);
11047 /* In contrast to implicit instantiation, where only the
11048 declarations, and not the definitions, of members are
11049 instantiated, we have here:
11053 The explicit instantiation of a class template specialization
11054 implies the instantiation of all of its members not
11055 previously explicitly specialized in the translation unit
11056 containing the explicit instantiation.
11058 Of course, we can't instantiate member template classes, since
11059 we don't have any arguments for them. Note that the standard
11060 is unclear on whether the instantiation of the members are
11061 *explicit* instantiations or not. However, the most natural
11062 interpretation is that it should be an explicit instantiation. */
11065 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
11066 if (TREE_CODE (tmp) == FUNCTION_DECL
11067 && DECL_TEMPLATE_INSTANTIATION (tmp))
11068 instantiate_class_member (tmp, extern_p);
11070 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
11071 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
11072 instantiate_class_member (tmp, extern_p);
11074 if (CLASSTYPE_NESTED_UTDS (t))
11075 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
11076 bt_instantiate_type_proc, &storage);
11080 /* Given a function DECL, which is a specialization of TMPL, modify
11081 DECL to be a re-instantiation of TMPL with the same template
11082 arguments. TMPL should be the template into which tsubst'ing
11083 should occur for DECL, not the most general template.
11085 One reason for doing this is a scenario like this:
11088 void f(const T&, int i);
11090 void g() { f(3, 7); }
11093 void f(const T& t, const int i) { }
11095 Note that when the template is first instantiated, with
11096 instantiate_template, the resulting DECL will have no name for the
11097 first parameter, and the wrong type for the second. So, when we go
11098 to instantiate the DECL, we regenerate it. */
11101 regenerate_decl_from_template (tree decl, tree tmpl)
11103 /* The arguments used to instantiate DECL, from the most general
11108 args = DECL_TI_ARGS (decl);
11109 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
11111 /* Make sure that we can see identifiers, and compute access
11113 push_access_scope (decl);
11115 if (TREE_CODE (decl) == FUNCTION_DECL)
11123 args_depth = TMPL_ARGS_DEPTH (args);
11124 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
11125 if (args_depth > parms_depth)
11126 args = get_innermost_template_args (args, parms_depth);
11128 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
11129 args, tf_error, NULL_TREE);
11131 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
11134 /* Merge parameter declarations. */
11135 decl_parm = skip_artificial_parms_for (decl,
11136 DECL_ARGUMENTS (decl));
11138 = skip_artificial_parms_for (code_pattern,
11139 DECL_ARGUMENTS (code_pattern));
11144 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
11145 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
11146 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
11148 parm_type = type_decays_to (parm_type);
11149 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
11150 TREE_TYPE (decl_parm) = parm_type;
11151 decl_parm = TREE_CHAIN (decl_parm);
11152 pattern_parm = TREE_CHAIN (pattern_parm);
11155 /* Merge additional specifiers from the CODE_PATTERN. */
11156 if (DECL_DECLARED_INLINE_P (code_pattern)
11157 && !DECL_DECLARED_INLINE_P (decl))
11158 DECL_DECLARED_INLINE_P (decl) = 1;
11159 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
11160 DECL_INLINE (decl) = 1;
11162 else if (TREE_CODE (decl) == VAR_DECL)
11164 if (!DECL_INITIALIZED_IN_CLASS_P (decl)
11165 && DECL_INITIAL (code_pattern))
11166 DECL_INITIAL (decl) =
11167 tsubst_expr (DECL_INITIAL (code_pattern), args,
11168 tf_error, DECL_TI_TEMPLATE (decl));
11171 gcc_unreachable ();
11173 pop_access_scope (decl);
11176 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
11177 substituted to get DECL. */
11180 template_for_substitution (tree decl)
11182 tree tmpl = DECL_TI_TEMPLATE (decl);
11184 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
11185 for the instantiation. This is not always the most general
11186 template. Consider, for example:
11189 struct S { template <class U> void f();
11190 template <> void f<int>(); };
11192 and an instantiation of S<double>::f<int>. We want TD to be the
11193 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
11194 while (/* An instantiation cannot have a definition, so we need a
11195 more general template. */
11196 DECL_TEMPLATE_INSTANTIATION (tmpl)
11197 /* We must also deal with friend templates. Given:
11199 template <class T> struct S {
11200 template <class U> friend void f() {};
11203 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
11204 so far as the language is concerned, but that's still
11205 where we get the pattern for the instantiation from. On
11206 other hand, if the definition comes outside the class, say:
11208 template <class T> struct S {
11209 template <class U> friend void f();
11211 template <class U> friend void f() {}
11213 we don't need to look any further. That's what the check for
11214 DECL_INITIAL is for. */
11215 || (TREE_CODE (decl) == FUNCTION_DECL
11216 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
11217 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
11219 /* The present template, TD, should not be a definition. If it
11220 were a definition, we should be using it! Note that we
11221 cannot restructure the loop to just keep going until we find
11222 a template with a definition, since that might go too far if
11223 a specialization was declared, but not defined. */
11224 gcc_assert (TREE_CODE (decl) != VAR_DECL
11225 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
11227 /* Fetch the more general template. */
11228 tmpl = DECL_TI_TEMPLATE (tmpl);
11234 /* Produce the definition of D, a _DECL generated from a template. If
11235 DEFER_OK is nonzero, then we don't have to actually do the
11236 instantiation now; we just have to do it sometime. Normally it is
11237 an error if this is an explicit instantiation but D is undefined.
11238 If UNDEFINED_OK is nonzero, then instead we treat it as an implicit
11239 instantiation. UNDEFINED_OK is nonzero only if we are being used
11240 to instantiate the members of an explicitly instantiated class
11245 instantiate_decl (tree d, int defer_ok, int undefined_ok)
11247 tree tmpl = DECL_TI_TEMPLATE (d);
11254 int pattern_defined;
11256 location_t saved_loc = input_location;
11258 /* This function should only be used to instantiate templates for
11259 functions and static member variables. */
11260 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
11261 || TREE_CODE (d) == VAR_DECL);
11263 /* Variables are never deferred; if instantiation is required, they
11264 are instantiated right away. That allows for better code in the
11265 case that an expression refers to the value of the variable --
11266 if the variable has a constant value the referring expression can
11267 take advantage of that fact. */
11268 if (TREE_CODE (d) == VAR_DECL)
11271 /* Don't instantiate cloned functions. Instead, instantiate the
11272 functions they cloned. */
11273 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
11274 d = DECL_CLONED_FUNCTION (d);
11276 if (DECL_TEMPLATE_INSTANTIATED (d))
11277 /* D has already been instantiated. It might seem reasonable to
11278 check whether or not D is an explicit instantiation, and, if so,
11279 stop here. But when an explicit instantiation is deferred
11280 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
11281 is set, even though we still need to do the instantiation. */
11284 /* If we already have a specialization of this declaration, then
11285 there's no reason to instantiate it. Note that
11286 retrieve_specialization gives us both instantiations and
11287 specializations, so we must explicitly check
11288 DECL_TEMPLATE_SPECIALIZATION. */
11289 gen_tmpl = most_general_template (tmpl);
11290 gen_args = DECL_TI_ARGS (d);
11291 spec = retrieve_specialization (gen_tmpl, gen_args,
11292 /*class_specializations_p=*/false);
11293 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
11296 /* This needs to happen before any tsubsting. */
11297 if (! push_tinst_level (d))
11300 timevar_push (TV_PARSE);
11302 /* We may be in the middle of deferred access check. Disable it now. */
11303 push_deferring_access_checks (dk_no_deferred);
11305 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
11306 for the instantiation. */
11307 td = template_for_substitution (d);
11308 code_pattern = DECL_TEMPLATE_RESULT (td);
11310 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
11311 || DECL_TEMPLATE_SPECIALIZATION (td))
11312 /* In the case of a friend template whose definition is provided
11313 outside the class, we may have too many arguments. Drop the
11314 ones we don't need. The same is true for specializations. */
11315 args = get_innermost_template_args
11316 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
11320 if (TREE_CODE (d) == FUNCTION_DECL)
11321 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
11323 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
11324 /* Unless an explicit instantiation directive has already determined
11325 the linkage of D, remember that a definition is available for
11327 if (pattern_defined
11328 && !DECL_INTERFACE_KNOWN (d)
11329 && !DECL_NOT_REALLY_EXTERN (d))
11330 mark_definable (d);
11332 input_location = DECL_SOURCE_LOCATION (d);
11334 if (! pattern_defined && DECL_EXPLICIT_INSTANTIATION (d) && undefined_ok)
11336 DECL_NOT_REALLY_EXTERN (d) = 0;
11337 SET_DECL_IMPLICIT_INSTANTIATION (d);
11342 /* Recheck the substitutions to obtain any warning messages
11343 about ignoring cv qualifiers. */
11344 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
11345 tree type = TREE_TYPE (gen);
11347 /* Make sure that we can see identifiers, and compute access
11348 correctly. D is already the target FUNCTION_DECL with the
11350 push_access_scope (d);
11352 if (TREE_CODE (gen) == FUNCTION_DECL)
11354 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_error | tf_warning, d);
11355 tsubst (TYPE_RAISES_EXCEPTIONS (type), gen_args,
11356 tf_error | tf_warning, d);
11357 /* Don't simply tsubst the function type, as that will give
11358 duplicate warnings about poor parameter qualifications.
11359 The function arguments are the same as the decl_arguments
11360 without the top level cv qualifiers. */
11361 type = TREE_TYPE (type);
11363 tsubst (type, gen_args, tf_error | tf_warning, d);
11365 pop_access_scope (d);
11368 /* We should have set up DECL_INITIAL in instantiate_class_template
11369 for in-class definitions of static data members. */
11370 gcc_assert (!(TREE_CODE (d) == VAR_DECL
11371 && DECL_INITIALIZED_IN_CLASS_P (d)
11372 && DECL_INITIAL (d) == NULL_TREE));
11374 /* Do not instantiate templates that we know will be defined
11376 if (DECL_INTERFACE_KNOWN (d)
11377 && DECL_REALLY_EXTERN (d)
11378 && ! (TREE_CODE (d) == FUNCTION_DECL
11379 && DECL_INLINE (d)))
11381 /* Defer all other templates, unless we have been explicitly
11382 forbidden from doing so. We restore the source position here
11383 because it's used by add_pending_template. */
11384 else if (! pattern_defined || defer_ok)
11386 input_location = saved_loc;
11388 if (at_eof && !pattern_defined
11389 && DECL_EXPLICIT_INSTANTIATION (d))
11392 The definition of a non-exported function template, a
11393 non-exported member function template, or a non-exported
11394 member function or static data member of a class template
11395 shall be present in every translation unit in which it is
11396 explicitly instantiated. */
11398 ("explicit instantiation of %qD but no definition available", d);
11400 add_pending_template (d);
11403 /* Tell the repository that D is available in this translation unit
11404 -- and see if it is supposed to be instantiated here. */
11405 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
11407 /* In a PCH file, despite the fact that the repository hasn't
11408 requested instantiation in the PCH it is still possible that
11409 an instantiation will be required in a file that includes the
11412 add_pending_template (d);
11413 /* Instantiate inline functions so that the inliner can do its
11414 job, even though we'll not be emitting a copy of this
11416 if (!(TREE_CODE (d) == FUNCTION_DECL
11417 && flag_inline_trees
11418 && DECL_DECLARED_INLINE_P (d)))
11422 need_push = !cfun || !global_bindings_p ();
11424 push_to_top_level ();
11426 /* Mark D as instantiated so that recursive calls to
11427 instantiate_decl do not try to instantiate it again. */
11428 DECL_TEMPLATE_INSTANTIATED (d) = 1;
11430 /* Regenerate the declaration in case the template has been modified
11431 by a subsequent redeclaration. */
11432 regenerate_decl_from_template (d, td);
11434 /* We already set the file and line above. Reset them now in case
11435 they changed as a result of calling regenerate_decl_from_template. */
11436 input_location = DECL_SOURCE_LOCATION (d);
11438 if (TREE_CODE (d) == VAR_DECL)
11440 /* Clear out DECL_RTL; whatever was there before may not be right
11441 since we've reset the type of the declaration. */
11442 SET_DECL_RTL (d, NULL_RTX);
11443 DECL_IN_AGGR_P (d) = 0;
11445 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
11446 initializer. That function will defer actual emission until
11447 we have a chance to determine linkage. */
11448 DECL_EXTERNAL (d) = 0;
11450 /* Enter the scope of D so that access-checking works correctly. */
11451 push_nested_class (DECL_CONTEXT (d));
11453 (!DECL_INITIALIZED_IN_CLASS_P (d)
11454 ? DECL_INITIAL (d) : NULL_TREE),
11456 pop_nested_class ();
11458 else if (TREE_CODE (d) == FUNCTION_DECL)
11460 htab_t saved_local_specializations;
11465 /* Save away the current list, in case we are instantiating one
11466 template from within the body of another. */
11467 saved_local_specializations = local_specializations;
11469 /* Set up the list of local specializations. */
11470 local_specializations = htab_create (37,
11471 hash_local_specialization,
11472 eq_local_specializations,
11475 /* Set up context. */
11476 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
11478 /* Create substitution entries for the parameters. */
11479 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
11480 tmpl_parm = DECL_ARGUMENTS (subst_decl);
11481 spec_parm = DECL_ARGUMENTS (d);
11482 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
11484 register_local_specialization (spec_parm, tmpl_parm);
11485 spec_parm = skip_artificial_parms_for (d, spec_parm);
11486 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
11490 register_local_specialization (spec_parm, tmpl_parm);
11491 tmpl_parm = TREE_CHAIN (tmpl_parm);
11492 spec_parm = TREE_CHAIN (spec_parm);
11494 gcc_assert (!spec_parm);
11496 /* Substitute into the body of the function. */
11497 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
11498 tf_error | tf_warning, tmpl);
11500 /* We don't need the local specializations any more. */
11501 htab_delete (local_specializations);
11502 local_specializations = saved_local_specializations;
11504 /* Finish the function. */
11505 d = finish_function (0);
11506 expand_or_defer_fn (d);
11509 /* We're not deferring instantiation any more. */
11510 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
11513 pop_from_top_level ();
11516 input_location = saved_loc;
11517 pop_deferring_access_checks ();
11518 pop_tinst_level ();
11520 timevar_pop (TV_PARSE);
11525 /* Run through the list of templates that we wish we could
11526 instantiate, and instantiate any we can. RETRIES is the
11527 number of times we retry pending template instantiation. */
11530 instantiate_pending_templates (int retries)
11533 tree last = NULL_TREE;
11535 location_t saved_loc = input_location;
11537 /* Instantiating templates may trigger vtable generation. This in turn
11538 may require further template instantiations. We place a limit here
11539 to avoid infinite loop. */
11540 if (pending_templates && retries >= max_tinst_depth)
11542 cp_error_at ("template instantiation depth exceeds maximum of %d"
11543 " (use -ftemplate-depth-NN to increase the maximum)"
11544 " instantiating %q+D, possibly from virtual table"
11546 max_tinst_depth, TREE_VALUE (pending_templates));
11554 t = &pending_templates;
11557 tree instantiation = TREE_VALUE (*t);
11559 reopen_tinst_level (TREE_PURPOSE (*t));
11561 if (TYPE_P (instantiation))
11565 if (!COMPLETE_TYPE_P (instantiation))
11567 instantiate_class_template (instantiation);
11568 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
11569 for (fn = TYPE_METHODS (instantiation);
11571 fn = TREE_CHAIN (fn))
11572 if (! DECL_ARTIFICIAL (fn))
11573 instantiate_decl (fn, /*defer_ok=*/0,
11574 /*undefined_ok=*/0);
11575 if (COMPLETE_TYPE_P (instantiation))
11579 if (COMPLETE_TYPE_P (instantiation))
11580 /* If INSTANTIATION has been instantiated, then we don't
11581 need to consider it again in the future. */
11582 *t = TREE_CHAIN (*t);
11586 t = &TREE_CHAIN (*t);
11591 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
11592 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
11594 instantiation = instantiate_decl (instantiation,
11596 /*undefined_ok=*/0);
11597 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
11601 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
11602 || DECL_TEMPLATE_INSTANTIATED (instantiation))
11603 /* If INSTANTIATION has been instantiated, then we don't
11604 need to consider it again in the future. */
11605 *t = TREE_CHAIN (*t);
11609 t = &TREE_CHAIN (*t);
11613 current_tinst_level = NULL_TREE;
11615 last_pending_template = last;
11617 while (reconsider);
11619 input_location = saved_loc;
11622 /* Substitute ARGVEC into T, which is a list of initializers for
11623 either base class or a non-static data member. The TREE_PURPOSEs
11624 are DECLs, and the TREE_VALUEs are the initializer values. Used by
11625 instantiate_decl. */
11628 tsubst_initializer_list (tree t, tree argvec)
11630 tree inits = NULL_TREE;
11632 for (; t; t = TREE_CHAIN (t))
11637 decl = tsubst_copy (TREE_PURPOSE (t), argvec, tf_error | tf_warning,
11639 decl = expand_member_init (decl);
11640 if (decl && !DECL_P (decl))
11641 in_base_initializer = 1;
11643 init = tsubst_expr (TREE_VALUE (t), argvec, tf_error | tf_warning,
11645 in_base_initializer = 0;
11649 init = build_tree_list (decl, init);
11650 TREE_CHAIN (init) = inits;
11657 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
11660 set_current_access_from_decl (tree decl)
11662 if (TREE_PRIVATE (decl))
11663 current_access_specifier = access_private_node;
11664 else if (TREE_PROTECTED (decl))
11665 current_access_specifier = access_protected_node;
11667 current_access_specifier = access_public_node;
11670 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
11671 is the instantiation (which should have been created with
11672 start_enum) and ARGS are the template arguments to use. */
11675 tsubst_enum (tree tag, tree newtag, tree args)
11679 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
11684 decl = TREE_VALUE (e);
11685 /* Note that in a template enum, the TREE_VALUE is the
11686 CONST_DECL, not the corresponding INTEGER_CST. */
11687 value = tsubst_expr (DECL_INITIAL (decl),
11688 args, tf_error | tf_warning,
11691 /* Give this enumeration constant the correct access. */
11692 set_current_access_from_decl (decl);
11694 /* Actually build the enumerator itself. */
11695 build_enumerator (DECL_NAME (decl), value, newtag);
11698 finish_enum (newtag);
11699 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
11700 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
11703 /* DECL is a FUNCTION_DECL that is a template specialization. Return
11704 its type -- but without substituting the innermost set of template
11705 arguments. So, innermost set of template parameters will appear in
11709 get_mostly_instantiated_function_type (tree decl)
11717 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
11718 targs = DECL_TI_ARGS (decl);
11719 tparms = DECL_TEMPLATE_PARMS (tmpl);
11720 parm_depth = TMPL_PARMS_DEPTH (tparms);
11722 /* There should be as many levels of arguments as there are levels
11724 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
11726 fn_type = TREE_TYPE (tmpl);
11728 if (parm_depth == 1)
11729 /* No substitution is necessary. */
11733 int i, save_access_control;
11736 /* Replace the innermost level of the TARGS with NULL_TREEs to
11737 let tsubst know not to substitute for those parameters. */
11738 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
11739 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
11740 SET_TMPL_ARGS_LEVEL (partial_args, i,
11741 TMPL_ARGS_LEVEL (targs, i));
11742 SET_TMPL_ARGS_LEVEL (partial_args,
11743 TMPL_ARGS_DEPTH (targs),
11744 make_tree_vec (DECL_NTPARMS (tmpl)));
11746 /* Disable access control as this function is used only during
11748 save_access_control = flag_access_control;
11749 flag_access_control = 0;
11751 ++processing_template_decl;
11752 /* Now, do the (partial) substitution to figure out the
11753 appropriate function type. */
11754 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
11755 --processing_template_decl;
11757 /* Substitute into the template parameters to obtain the real
11758 innermost set of parameters. This step is important if the
11759 innermost set of template parameters contains value
11760 parameters whose types depend on outer template parameters. */
11761 TREE_VEC_LENGTH (partial_args)--;
11762 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
11764 flag_access_control = save_access_control;
11770 /* Return truthvalue if we're processing a template different from
11771 the last one involved in diagnostics. */
11773 problematic_instantiation_changed (void)
11775 return last_template_error_tick != tinst_level_tick;
11778 /* Remember current template involved in diagnostics. */
11780 record_last_problematic_instantiation (void)
11782 last_template_error_tick = tinst_level_tick;
11786 current_instantiation (void)
11788 return current_tinst_level;
11791 /* [temp.param] Check that template non-type parm TYPE is of an allowable
11792 type. Return zero for ok, nonzero for disallowed. Issue error and
11793 warning messages under control of COMPLAIN. */
11796 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
11798 if (INTEGRAL_TYPE_P (type))
11800 else if (POINTER_TYPE_P (type))
11802 else if (TYPE_PTR_TO_MEMBER_P (type))
11804 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11806 else if (TREE_CODE (type) == TYPENAME_TYPE)
11809 if (complain & tf_error)
11810 error ("%q#T is not a valid type for a template constant parameter", type);
11814 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
11815 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
11818 dependent_type_p_r (tree type)
11824 A type is dependent if it is:
11826 -- a template parameter. Template template parameters are types
11827 for us (since TYPE_P holds true for them) so we handle
11829 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
11830 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
11832 /* -- a qualified-id with a nested-name-specifier which contains a
11833 class-name that names a dependent type or whose unqualified-id
11834 names a dependent type. */
11835 if (TREE_CODE (type) == TYPENAME_TYPE)
11837 /* -- a cv-qualified type where the cv-unqualified type is
11839 type = TYPE_MAIN_VARIANT (type);
11840 /* -- a compound type constructed from any dependent type. */
11841 if (TYPE_PTR_TO_MEMBER_P (type))
11842 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
11843 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
11845 else if (TREE_CODE (type) == POINTER_TYPE
11846 || TREE_CODE (type) == REFERENCE_TYPE)
11847 return dependent_type_p (TREE_TYPE (type));
11848 else if (TREE_CODE (type) == FUNCTION_TYPE
11849 || TREE_CODE (type) == METHOD_TYPE)
11853 if (dependent_type_p (TREE_TYPE (type)))
11855 for (arg_type = TYPE_ARG_TYPES (type);
11857 arg_type = TREE_CHAIN (arg_type))
11858 if (dependent_type_p (TREE_VALUE (arg_type)))
11862 /* -- an array type constructed from any dependent type or whose
11863 size is specified by a constant expression that is
11864 value-dependent. */
11865 if (TREE_CODE (type) == ARRAY_TYPE)
11867 if (TYPE_DOMAIN (type)
11868 && ((value_dependent_expression_p
11869 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
11870 || (type_dependent_expression_p
11871 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
11873 return dependent_type_p (TREE_TYPE (type));
11876 /* -- a template-id in which either the template name is a template
11878 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
11880 /* ... or any of the template arguments is a dependent type or
11881 an expression that is type-dependent or value-dependent. */
11882 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
11883 && (any_dependent_template_arguments_p
11884 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
11887 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
11888 expression is not type-dependent, then it should already been
11890 if (TREE_CODE (type) == TYPEOF_TYPE)
11893 /* The standard does not specifically mention types that are local
11894 to template functions or local classes, but they should be
11895 considered dependent too. For example:
11897 template <int I> void f() {
11902 The size of `E' cannot be known until the value of `I' has been
11903 determined. Therefore, `E' must be considered dependent. */
11904 scope = TYPE_CONTEXT (type);
11905 if (scope && TYPE_P (scope))
11906 return dependent_type_p (scope);
11907 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
11908 return type_dependent_expression_p (scope);
11910 /* Other types are non-dependent. */
11914 /* Returns TRUE if TYPE is dependent, in the sense of
11915 [temp.dep.type]. */
11918 dependent_type_p (tree type)
11920 /* If there are no template parameters in scope, then there can't be
11921 any dependent types. */
11922 if (!processing_template_decl)
11925 /* If the type is NULL, we have not computed a type for the entity
11926 in question; in that case, the type is dependent. */
11930 /* Erroneous types can be considered non-dependent. */
11931 if (type == error_mark_node)
11934 /* If we have not already computed the appropriate value for TYPE,
11936 if (!TYPE_DEPENDENT_P_VALID (type))
11938 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
11939 TYPE_DEPENDENT_P_VALID (type) = 1;
11942 return TYPE_DEPENDENT_P (type);
11945 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
11948 dependent_scope_ref_p (tree expression, bool criterion (tree))
11953 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
11955 if (!TYPE_P (TREE_OPERAND (expression, 0)))
11958 scope = TREE_OPERAND (expression, 0);
11959 name = TREE_OPERAND (expression, 1);
11963 An id-expression is type-dependent if it contains a
11964 nested-name-specifier that contains a class-name that names a
11966 /* The suggested resolution to Core Issue 2 implies that if the
11967 qualifying type is the current class, then we must peek
11970 && currently_open_class (scope)
11971 && !criterion (name))
11973 if (dependent_type_p (scope))
11979 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
11980 [temp.dep.constexpr] */
11983 value_dependent_expression_p (tree expression)
11985 if (!processing_template_decl)
11988 /* A name declared with a dependent type. */
11989 if (TREE_CODE (expression) == IDENTIFIER_NODE
11990 || (DECL_P (expression)
11991 && type_dependent_expression_p (expression)))
11993 /* A non-type template parameter. */
11994 if ((TREE_CODE (expression) == CONST_DECL
11995 && DECL_TEMPLATE_PARM_P (expression))
11996 || TREE_CODE (expression) == TEMPLATE_PARM_INDEX)
11998 /* A constant with integral or enumeration type and is initialized
11999 with an expression that is value-dependent. */
12000 if (TREE_CODE (expression) == VAR_DECL
12001 && DECL_INITIAL (expression)
12002 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
12003 && value_dependent_expression_p (DECL_INITIAL (expression)))
12005 /* These expressions are value-dependent if the type to which the
12006 cast occurs is dependent or the expression being casted is
12007 value-dependent. */
12008 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
12009 || TREE_CODE (expression) == STATIC_CAST_EXPR
12010 || TREE_CODE (expression) == CONST_CAST_EXPR
12011 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
12012 || TREE_CODE (expression) == CAST_EXPR)
12014 tree type = TREE_TYPE (expression);
12015 if (dependent_type_p (type))
12017 /* A functional cast has a list of operands. */
12018 expression = TREE_OPERAND (expression, 0);
12021 /* If there are no operands, it must be an expression such
12022 as "int()". This should not happen for aggregate types
12023 because it would form non-constant expressions. */
12024 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
12028 if (TREE_CODE (expression) == TREE_LIST)
12032 if (value_dependent_expression_p (TREE_VALUE (expression)))
12034 expression = TREE_CHAIN (expression);
12036 while (expression);
12040 return value_dependent_expression_p (expression);
12042 /* A `sizeof' expression is value-dependent if the operand is
12044 if (TREE_CODE (expression) == SIZEOF_EXPR
12045 || TREE_CODE (expression) == ALIGNOF_EXPR)
12047 expression = TREE_OPERAND (expression, 0);
12048 if (TYPE_P (expression))
12049 return dependent_type_p (expression);
12050 return type_dependent_expression_p (expression);
12052 if (TREE_CODE (expression) == SCOPE_REF)
12053 return dependent_scope_ref_p (expression, value_dependent_expression_p);
12054 if (TREE_CODE (expression) == COMPONENT_REF)
12055 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
12056 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
12058 /* A CALL_EXPR is value-dependent if any argument is
12059 value-dependent. Why do we have to handle CALL_EXPRs in this
12060 function at all? First, some function calls, those for which
12061 value_dependent_expression_p is true, man appear in constant
12062 expressions. Second, there appear to be bugs which result in
12063 other CALL_EXPRs reaching this point. */
12064 if (TREE_CODE (expression) == CALL_EXPR)
12066 tree function = TREE_OPERAND (expression, 0);
12067 tree args = TREE_OPERAND (expression, 1);
12069 if (value_dependent_expression_p (function))
12073 else if (TREE_CODE (args) == TREE_LIST)
12077 if (value_dependent_expression_p (TREE_VALUE (args)))
12079 args = TREE_CHAIN (args);
12085 return value_dependent_expression_p (args);
12087 /* A constant expression is value-dependent if any subexpression is
12088 value-dependent. */
12089 if (EXPR_P (expression))
12091 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
12094 return (value_dependent_expression_p
12095 (TREE_OPERAND (expression, 0)));
12096 case tcc_comparison:
12098 return ((value_dependent_expression_p
12099 (TREE_OPERAND (expression, 0)))
12100 || (value_dependent_expression_p
12101 (TREE_OPERAND (expression, 1))));
12102 case tcc_expression:
12105 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
12106 /* In some cases, some of the operands may be missing.
12107 (For example, in the case of PREDECREMENT_EXPR, the
12108 amount to increment by may be missing.) That doesn't
12109 make the expression dependent. */
12110 if (TREE_OPERAND (expression, i)
12111 && (value_dependent_expression_p
12112 (TREE_OPERAND (expression, i))))
12116 case tcc_reference:
12117 case tcc_statement:
12118 /* These cannot be value dependent. */
12122 gcc_unreachable ();
12126 /* The expression is not value-dependent. */
12130 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
12131 [temp.dep.expr]. */
12134 type_dependent_expression_p (tree expression)
12136 if (!processing_template_decl)
12139 if (expression == error_mark_node)
12142 /* An unresolved name is always dependent. */
12143 if (TREE_CODE (expression) == IDENTIFIER_NODE)
12146 /* Some expression forms are never type-dependent. */
12147 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
12148 || TREE_CODE (expression) == SIZEOF_EXPR
12149 || TREE_CODE (expression) == ALIGNOF_EXPR
12150 || TREE_CODE (expression) == TYPEID_EXPR
12151 || TREE_CODE (expression) == DELETE_EXPR
12152 || TREE_CODE (expression) == VEC_DELETE_EXPR
12153 || TREE_CODE (expression) == THROW_EXPR)
12156 /* The types of these expressions depends only on the type to which
12157 the cast occurs. */
12158 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
12159 || TREE_CODE (expression) == STATIC_CAST_EXPR
12160 || TREE_CODE (expression) == CONST_CAST_EXPR
12161 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
12162 || TREE_CODE (expression) == CAST_EXPR)
12163 return dependent_type_p (TREE_TYPE (expression));
12165 /* The types of these expressions depends only on the type created
12166 by the expression. */
12167 if (TREE_CODE (expression) == NEW_EXPR
12168 || TREE_CODE (expression) == VEC_NEW_EXPR)
12170 /* For NEW_EXPR tree nodes created inside a template, either
12171 the object type itself or a TREE_LIST may appear as the
12173 tree type = TREE_OPERAND (expression, 1);
12174 if (TREE_CODE (type) == TREE_LIST)
12175 /* This is an array type. We need to check array dimensions
12177 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
12178 || value_dependent_expression_p
12179 (TREE_OPERAND (TREE_VALUE (type), 1));
12181 return dependent_type_p (type);
12184 if (TREE_CODE (expression) == SCOPE_REF
12185 && dependent_scope_ref_p (expression,
12186 type_dependent_expression_p))
12189 if (TREE_CODE (expression) == FUNCTION_DECL
12190 && DECL_LANG_SPECIFIC (expression)
12191 && DECL_TEMPLATE_INFO (expression)
12192 && (any_dependent_template_arguments_p
12193 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
12196 if (TREE_CODE (expression) == TEMPLATE_DECL
12197 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
12200 if (TREE_TYPE (expression) == unknown_type_node)
12202 if (TREE_CODE (expression) == ADDR_EXPR)
12203 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
12204 if (TREE_CODE (expression) == COMPONENT_REF
12205 || TREE_CODE (expression) == OFFSET_REF)
12207 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
12209 expression = TREE_OPERAND (expression, 1);
12210 if (TREE_CODE (expression) == IDENTIFIER_NODE)
12213 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
12214 if (TREE_CODE (expression) == SCOPE_REF)
12217 if (TREE_CODE (expression) == BASELINK)
12218 expression = BASELINK_FUNCTIONS (expression);
12220 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
12222 if (any_dependent_template_arguments_p
12223 (TREE_OPERAND (expression, 1)))
12225 expression = TREE_OPERAND (expression, 0);
12227 gcc_assert (TREE_CODE (expression) == OVERLOAD);
12231 if (type_dependent_expression_p (OVL_CURRENT (expression)))
12233 expression = OVL_NEXT (expression);
12238 return (dependent_type_p (TREE_TYPE (expression)));
12241 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
12242 contains a type-dependent expression. */
12245 any_type_dependent_arguments_p (tree args)
12249 tree arg = TREE_VALUE (args);
12251 if (type_dependent_expression_p (arg))
12253 args = TREE_CHAIN (args);
12258 /* Returns TRUE if the ARG (a template argument) is dependent. */
12261 dependent_template_arg_p (tree arg)
12263 if (!processing_template_decl)
12266 if (TREE_CODE (arg) == TEMPLATE_DECL
12267 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12268 return dependent_template_p (arg);
12269 else if (TYPE_P (arg))
12270 return dependent_type_p (arg);
12272 return (type_dependent_expression_p (arg)
12273 || value_dependent_expression_p (arg));
12276 /* Returns true if ARGS (a collection of template arguments) contains
12277 any dependent arguments. */
12280 any_dependent_template_arguments_p (tree args)
12288 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
12290 tree level = TMPL_ARGS_LEVEL (args, i + 1);
12291 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
12292 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
12299 /* Returns TRUE if the template TMPL is dependent. */
12302 dependent_template_p (tree tmpl)
12304 if (TREE_CODE (tmpl) == OVERLOAD)
12308 if (dependent_template_p (OVL_FUNCTION (tmpl)))
12310 tmpl = OVL_CHAIN (tmpl);
12315 /* Template template parameters are dependent. */
12316 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
12317 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
12319 /* So are names that have not been looked up. */
12320 if (TREE_CODE (tmpl) == SCOPE_REF
12321 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
12323 /* So are member templates of dependent classes. */
12324 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
12325 return dependent_type_p (DECL_CONTEXT (tmpl));
12329 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
12332 dependent_template_id_p (tree tmpl, tree args)
12334 return (dependent_template_p (tmpl)
12335 || any_dependent_template_arguments_p (args));
12338 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
12339 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
12340 can be found. Note that this function peers inside uninstantiated
12341 templates and therefore should be used only in extremely limited
12345 resolve_typename_type (tree type, bool only_current_p)
12353 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
12355 scope = TYPE_CONTEXT (type);
12356 name = TYPE_IDENTIFIER (type);
12358 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
12359 it first before we can figure out what NAME refers to. */
12360 if (TREE_CODE (scope) == TYPENAME_TYPE)
12361 scope = resolve_typename_type (scope, only_current_p);
12362 /* If we don't know what SCOPE refers to, then we cannot resolve the
12364 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
12365 return error_mark_node;
12366 /* If the SCOPE is a template type parameter, we have no way of
12367 resolving the name. */
12368 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
12370 /* If the SCOPE is not the current instantiation, there's no reason
12371 to look inside it. */
12372 if (only_current_p && !currently_open_class (scope))
12373 return error_mark_node;
12374 /* If SCOPE is a partial instantiation, it will not have a valid
12375 TYPE_FIELDS list, so use the original template. */
12376 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
12377 /* Enter the SCOPE so that name lookup will be resolved as if we
12378 were in the class definition. In particular, SCOPE will no
12379 longer be considered a dependent type. */
12380 pushed_scope = push_scope (scope);
12381 /* Look up the declaration. */
12382 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
12383 /* Obtain the set of qualifiers applied to the TYPE. */
12384 quals = cp_type_quals (type);
12385 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
12386 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
12388 type = error_mark_node;
12389 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
12390 && TREE_CODE (decl) == TYPE_DECL)
12391 type = TREE_TYPE (decl);
12392 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
12393 && DECL_CLASS_TEMPLATE_P (decl))
12397 /* Obtain the template and the arguments. */
12398 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
12399 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
12400 /* Instantiate the template. */
12401 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
12402 /*entering_scope=*/0, tf_error | tf_user);
12405 type = error_mark_node;
12406 /* Qualify the resulting type. */
12407 if (type != error_mark_node && quals)
12408 type = cp_build_qualified_type (type, quals);
12409 /* Leave the SCOPE. */
12411 pop_scope (pushed_scope);
12416 /* EXPR is an expression which is not type-dependent. Return a proxy
12417 for EXPR that can be used to compute the types of larger
12418 expressions containing EXPR. */
12421 build_non_dependent_expr (tree expr)
12425 /* Preserve null pointer constants so that the type of things like
12426 "p == 0" where "p" is a pointer can be determined. */
12427 if (null_ptr_cst_p (expr))
12429 /* Preserve OVERLOADs; the functions must be available to resolve
12431 inner_expr = (TREE_CODE (expr) == ADDR_EXPR ?
12432 TREE_OPERAND (expr, 0) : expr);
12433 if (TREE_CODE (inner_expr) == OVERLOAD
12434 || TREE_CODE (inner_expr) == FUNCTION_DECL
12435 || TREE_CODE (inner_expr) == TEMPLATE_DECL
12436 || TREE_CODE (inner_expr) == TEMPLATE_ID_EXPR
12437 || TREE_CODE (inner_expr) == OFFSET_REF)
12439 /* There is no need to return a proxy for a variable. */
12440 if (TREE_CODE (expr) == VAR_DECL)
12442 /* Preserve string constants; conversions from string constants to
12443 "char *" are allowed, even though normally a "const char *"
12444 cannot be used to initialize a "char *". */
12445 if (TREE_CODE (expr) == STRING_CST)
12447 /* Preserve arithmetic constants, as an optimization -- there is no
12448 reason to create a new node. */
12449 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
12451 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
12452 There is at least one place where we want to know that a
12453 particular expression is a throw-expression: when checking a ?:
12454 expression, there are special rules if the second or third
12455 argument is a throw-expression. */
12456 if (TREE_CODE (expr) == THROW_EXPR)
12459 if (TREE_CODE (expr) == COND_EXPR)
12460 return build3 (COND_EXPR,
12462 TREE_OPERAND (expr, 0),
12463 (TREE_OPERAND (expr, 1)
12464 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
12465 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
12466 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
12467 if (TREE_CODE (expr) == COMPOUND_EXPR
12468 && !COMPOUND_EXPR_OVERLOADED (expr))
12469 return build2 (COMPOUND_EXPR,
12471 TREE_OPERAND (expr, 0),
12472 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
12474 /* Otherwise, build a NON_DEPENDENT_EXPR.
12476 REFERENCE_TYPEs are not stripped for expressions in templates
12477 because doing so would play havoc with mangling. Consider, for
12480 template <typename T> void f<T& g>() { g(); }
12482 In the body of "f", the expression for "g" will have
12483 REFERENCE_TYPE, even though the standard says that it should
12484 not. The reason is that we must preserve the syntactic form of
12485 the expression so that mangling (say) "f<g>" inside the body of
12486 "f" works out correctly. Therefore, the REFERENCE_TYPE is
12488 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
12491 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
12492 Return a new TREE_LIST with the various arguments replaced with
12493 equivalent non-dependent expressions. */
12496 build_non_dependent_args (tree args)
12501 new_args = NULL_TREE;
12502 for (a = args; a; a = TREE_CHAIN (a))
12503 new_args = tree_cons (NULL_TREE,
12504 build_non_dependent_expr (TREE_VALUE (a)),
12506 return nreverse (new_args);
12509 #include "gt-cp-pt.h"